// Copyright 2019 Phyronnaz

#pragma once

#pragma warning( disable : 4101 4701 )
using Seed = int32;

#include "CoreMinimal.h"
#include "VoxelWorldGenerator.h"
#include "VoxelContext.h"
#include "VoxelNodeFunctions.h"
#include "FastNoise.h"
#include "Curves/RichCurve.h"
#include "Curves/CurveFloat.h"
#include "RingWorld.generated.h"


class FRingWorldInstance : public FVoxelWorldGeneratorInstance
{
public:
    struct FLocalComputeStruct_LocalValue_LOD0
    {
        struct FVoxelGraphOutputs
        {
            float& Value;
        };
        struct FVoxelConstantsCache
        {
            float Variable_52; // MountainsNoiseFrequency = 0.2 output 0
            float Variable_58; // PlainsNoiseHeight = 250.0 output 0
            float Variable_22; // RingEdgesHardness = 10.0 output 0
            float Variable_25; // PI.3.141593 output 0
            float Variable_31; // Width in Degrees = 50.0 output 0
            float Variable_66; // RiverDepth = 100.0 output 0
            float Variable_96; // Thickness = 500.0 output 0
            float Variable_40; // BaseHeight = 1000.0 output 0
            float Variable_43; // BaseNoiseHeight = 250.0 output 0
            float Variable_46; // BaseNoiseFrquency = 0.005 output 0
            float Variable_49; // MountainsNoiseHeight = 500.0 output 0
            float Variable_5; // Radius = 7000.0 output 0
            float Variable_95; // RiverWidth = 1.0 output 0
            float Variable_61; // PlainsNoiseFrequency = 0.2 output 0
            float Variable_98; // PI.3.141593 output 0
            float Variable_67; // PI.3.141593 output 0
            float Variable_90; // Scale = 10.0 output 0
            float Variable_91; // * output 0
            float Variable_37; // / output 0
            float Variable_97; // * output 0
            float Variable_6; // + output 0
            float Variable_92; // / output 0
            float Variable_36; // - output 0
        };
        struct FVoxelCache
        {
            float Variable_0; // X output 0
            float Variable_24; // X output 0
            float Variable_1; // Y output 0
            float Variable_29; // Y output 0
            float Variable_23; // ATAN2 output 0
            float Variable_26; // / output 0
            float Variable_28; // * output 0
            float Variable_45; // * output 0
            float Variable_51; // * output 0
            float Variable_60; // * output 0
            float Variable_79; // 2D Simplex Noise output 0
            float Variable_76; // * output 0
        };

        FLocalComputeStruct_LocalValue_LOD0(const float& InScale, const float& InPlainsNoiseHeight, const float& InRingEdgesHardness, const float& InWidth_in_Degrees, const float& InRiverDepth, const float& InThickness, const float& InBaseHeight, const float& InBaseNoiseHeight, const float& InBaseNoiseFrquency, const float& InMountainsNoiseHeight, const float& InRadius, const float& InRiverWidth, const float& InPlainsNoiseFrequency, const float& InMountainsNoiseFrequency, const FRichCurve& InRingShape, const FRichCurve& InMoutainsMask, const FRichCurve& InRiverMask, const FRichCurve& InPlainsNoiseStrength, const FLinearColor& InPlainsColorLow, const FLinearColor& InRiverColor, const FLinearColor& InBeachColor, const FLinearColor& InMountainsColorHigh, const FLinearColor& InMountainsColorLowLow, const FLinearColor& InMountainsColorLowHigh, const FLinearColor& InPlainsColorHigh, const FLinearColor& InRingOuterColor)
            : Scale(InScale)
            , PlainsNoiseHeight(InPlainsNoiseHeight)
            , RingEdgesHardness(InRingEdgesHardness)
            , Width_in_Degrees(InWidth_in_Degrees)
            , RiverDepth(InRiverDepth)
            , Thickness(InThickness)
            , BaseHeight(InBaseHeight)
            , BaseNoiseHeight(InBaseNoiseHeight)
            , BaseNoiseFrquency(InBaseNoiseFrquency)
            , MountainsNoiseHeight(InMountainsNoiseHeight)
            , Radius(InRadius)
            , RiverWidth(InRiverWidth)
            , PlainsNoiseFrequency(InPlainsNoiseFrequency)
            , MountainsNoiseFrequency(InMountainsNoiseFrequency)
            , RingShape(InRingShape)
            , MoutainsMask(InMoutainsMask)
            , RiverMask(InRiverMask)
            , PlainsNoiseStrength(InPlainsNoiseStrength)
            , PlainsColorLow(InPlainsColorLow)
            , RiverColor(InRiverColor)
            , BeachColor(InBeachColor)
            , MountainsColorHigh(InMountainsColorHigh)
            , MountainsColorLowLow(InMountainsColorLowLow)
            , MountainsColorLowHigh(InMountainsColorLowHigh)
            , PlainsColorHigh(InPlainsColorHigh)
            , RingOuterColor(InRingOuterColor)
        {
        }

        void Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            FVoxelCache Cache;

            {
            }

            Function0_Init(InitStruct);

            {
                // MountainsNoiseFrequency = 0.2
                ConstantsCache.Variable_52 = MountainsNoiseFrequency;

                // PlainsNoiseHeight = 250.0
                ConstantsCache.Variable_58 = PlainsNoiseHeight;

                // RingEdgesHardness = 10.0
                ConstantsCache.Variable_22 = RingEdgesHardness;

                // PI.3.141593
                ConstantsCache.Variable_25 = 3.141593;

                // Width in Degrees = 50.0
                ConstantsCache.Variable_31 = Width_in_Degrees;

                // RiverDepth = 100.0
                ConstantsCache.Variable_66 = RiverDepth;

                // Thickness = 500.0
                ConstantsCache.Variable_96 = Thickness;

                // BaseHeight = 1000.0
                ConstantsCache.Variable_40 = BaseHeight;

                // BaseNoiseHeight = 250.0
                ConstantsCache.Variable_43 = BaseNoiseHeight;

                // BaseNoiseFrquency = 0.005
                ConstantsCache.Variable_46 = BaseNoiseFrquency;

                // MountainsNoiseHeight = 500.0
                ConstantsCache.Variable_49 = MountainsNoiseHeight;

                // Radius = 7000.0
                ConstantsCache.Variable_5 = Radius;

                // RiverWidth = 1.0
                ConstantsCache.Variable_95 = RiverWidth;

                // PlainsNoiseFrequency = 0.2
                ConstantsCache.Variable_61 = PlainsNoiseFrequency;

                // PI.3.141593
                ConstantsCache.Variable_98 = 3.141593;

                // PI.3.141593
                ConstantsCache.Variable_67 = 3.141593;

                // Scale = 10.0
                ConstantsCache.Variable_90 = Scale;

                // *
                ConstantsCache.Variable_91 = ConstantsCache.Variable_5 * ConstantsCache.Variable_90;

                // /
                ConstantsCache.Variable_37 = ConstantsCache.Variable_31 / float(360.0f);

                // *
                ConstantsCache.Variable_97 = ConstantsCache.Variable_96 * ConstantsCache.Variable_90;

                // +
                ConstantsCache.Variable_6 = ConstantsCache.Variable_91 + ConstantsCache.Variable_97;

                // /
                ConstantsCache.Variable_92 = ConstantsCache.Variable_91 / ConstantsCache.Variable_90;

                // -
                ConstantsCache.Variable_36 = float(0.5f) - ConstantsCache.Variable_37;

            }
        }
        void ComputeX(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_X_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXY(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XY_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXYZ(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XYZ_Compute(GraphOutputs, Cache, Context);
        }
        void Get(const FVoxelContext&Context, float& Value) const
        {
            FVoxelGraphOutputs GraphOutputs{Value};
            Function0_Compute(GraphOutputs, Context);
        }

    private:
        FVoxelConstantsCache ConstantsCache;
        FastNoise _2D_Simplex_Noise_8747_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15560_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15561_Noise;
        FastNoise _2D_Perlin_Noise_7430_Noise;
        FastNoise _2D_Simplex_Noise_8748_Noise;

        const float& Scale;
        const float& PlainsNoiseHeight;
        const float& RingEdgesHardness;
        const float& Width_in_Degrees;
        const float& RiverDepth;
        const float& Thickness;
        const float& BaseHeight;
        const float& BaseNoiseHeight;
        const float& BaseNoiseFrquency;
        const float& MountainsNoiseHeight;
        const float& Radius;
        const float& RiverWidth;
        const float& PlainsNoiseFrequency;
        const float& MountainsNoiseFrequency;
        const FRichCurve& RingShape;
        const FRichCurve& MoutainsMask;
        const FRichCurve& RiverMask;
        const FRichCurve& PlainsNoiseStrength;
        const FLinearColor& PlainsColorLow;
        const FLinearColor& RiverColor;
        const FLinearColor& BeachColor;
        const FLinearColor& MountainsColorHigh;
        const FLinearColor& MountainsColorLowLow;
        const FLinearColor& MountainsColorLowHigh;
        const FLinearColor& PlainsColorHigh;
        const FLinearColor& RingOuterColor;

        ///////////////////////////////////////////////////////////////////////
        //////////////////////////// Init functions ///////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15560_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15560_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15560_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15560_Noise.SetFractalOctaves(5);
            _2D_Simplex_Noise_Fractal_15560_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15560_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15560_Noise.SetFractalType(FastNoise::FractalType::FBM);

            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15561_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15561_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15561_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15561_Noise.SetFractalOctaves(8);
            _2D_Simplex_Noise_Fractal_15561_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15561_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15561_Noise.SetFractalType(FastNoise::FractalType::FBM);

            // Init of 2D Perlin Noise
            _2D_Perlin_Noise_7430_Noise.SetSeed(Seed(1338));
            _2D_Perlin_Noise_7430_Noise.SetFrequency(0.1);
            _2D_Perlin_Noise_7430_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8748_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_8748_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_8748_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8747_Noise.SetSeed(Seed(1000));
            _2D_Simplex_Noise_8747_Noise.SetFrequency(0.001);
            _2D_Simplex_Noise_8747_Noise.SetInterp(FastNoise::Interp::Quintic);

        }

        ///////////////////////////////////////////////////////////////////////
        ////////////////////////// Compute functions //////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_X_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // X
            Cache.Variable_0 = Context.X;

            // X
            Cache.Variable_24 = Context.X;

        }

        void Function0_XY_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // Y
            Cache.Variable_1 = Context.Y;

            // Y
            Cache.Variable_29 = Context.Y;

            // ATAN2
            Cache.Variable_23 = FVoxelNodeFunctions::Atan2(Cache.Variable_29, Cache.Variable_24);

            // /
            Cache.Variable_26 = Cache.Variable_23 / ConstantsCache.Variable_25;

            // *
            Cache.Variable_28 = ConstantsCache.Variable_92 * Cache.Variable_26;

            // *
            Cache.Variable_45 = Cache.Variable_28 * ConstantsCache.Variable_46;

            // *
            Cache.Variable_51 = Cache.Variable_28 * ConstantsCache.Variable_52;

            // *
            Cache.Variable_60 = Cache.Variable_28 * ConstantsCache.Variable_61;

            // 2D Simplex Noise
            Cache.Variable_79 = _2D_Simplex_Noise_8747_Noise.GetSimplex(Cache.Variable_28, Cache.Variable_28);

            // *
            Cache.Variable_76 = Cache.Variable_79 * float(0.1f);

        }

        void Function0_XYZ_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // Z
            float Variable_12; // Z output 0
            Variable_12 = Context.Z;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Cache.Variable_0, Cache.Variable_1, Variable_2);

            // +
            float Variable_30; // + output 0
            Variable_30 = Variable_3 + float(0.001f);

            // /
            float Variable_13; // / output 0
            Variable_13 = Variable_12 / Variable_30;

            // ACOS
            float Variable_14; // ACOS output 0
            Variable_14 = FVoxelNodeFunctions::Acos(Variable_13);

            // /
            float Variable_10; // / output 0
            Variable_10 = Variable_14 / ConstantsCache.Variable_98;

            // 1 - X
            float Variable_11; // 1 - X output 0
            Variable_11 = 1 - Variable_10;

            // Min (float)
            float Variable_9; // Min (float) output 0
            Variable_9 = FVoxelNodeFunctions::Min<float>(Variable_10, Variable_11);

            // -
            float Variable_15; // - output 0
            Variable_15 = Variable_9 - ConstantsCache.Variable_36;

            // /
            float Variable_35; // / output 0
            Variable_35 = Variable_15 / ConstantsCache.Variable_37;

            // 1 - X
            float Variable_34; // 1 - X output 0
            Variable_34 = 1 - Variable_35;

            // RingCurve
            float Variable_38; // RingCurve output 0
            Variable_38 = RingShape.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_86; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_86 = FMath::Clamp<float>(Variable_38, 0.000000, 1.000000);

            // *
            float Variable_39; // * output 0
            Variable_39 = Variable_86 * ConstantsCache.Variable_40;

            // *
            float Variable_27; // * output 0
            Variable_27 = ConstantsCache.Variable_92 * Variable_10;

            // *
            float Variable_44; // * output 0
            Variable_44 = Variable_27 * ConstantsCache.Variable_46;

            // 2D Simplex Noise Fractal
            float Variable_41; // 2D Simplex Noise Fractal output 0
            Variable_41 = _2D_Simplex_Noise_Fractal_15560_Noise.GetSimplexFractal(Variable_44, Cache.Variable_45);

            // *
            float Variable_42; // * output 0
            Variable_42 = Variable_41 * ConstantsCache.Variable_43;

            // *
            float Variable_50; // * output 0
            Variable_50 = Variable_27 * ConstantsCache.Variable_52;

            // 2D Simplex Noise Fractal
            float Variable_47; // 2D Simplex Noise Fractal output 0
            Variable_47 = _2D_Simplex_Noise_Fractal_15561_Noise.GetSimplexFractal(Variable_50, Cache.Variable_51);

            // MountainsCurve
            float Variable_53; // MountainsCurve output 0
            Variable_53 = MoutainsMask.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_87; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_87 = FMath::Clamp<float>(Variable_53, 0.000000, 1.000000);

            // *
            float Variable_48; // * output 0
            Variable_48 = Variable_47 * ConstantsCache.Variable_49 * Variable_87;

            // 2D Perlin Noise
            float Variable_54; // 2D Perlin Noise output 0
            Variable_54 = _2D_Perlin_Noise_7430_Noise.GetPerlin(Variable_50, Cache.Variable_51);

            // *
            float Variable_55; // * output 0
            Variable_55 = ConstantsCache.Variable_49 * Variable_87 * Variable_54 * float(0.1f);

            // *
            float Variable_59; // * output 0
            Variable_59 = Variable_27 * ConstantsCache.Variable_61;

            // 2D Simplex Noise
            float Variable_63; // 2D Simplex Noise output 0
            Variable_63 = _2D_Simplex_Noise_8748_Noise.GetSimplex(Variable_59, Cache.Variable_60);

            // Z
            float Variable_72; // Z output 0
            Variable_72 = Context.Z;

            // /
            float Variable_73; // / output 0
            Variable_73 = Variable_72 / Variable_30;

            // +
            float Variable_75; // + output 0
            Variable_75 = Variable_73 + Cache.Variable_76;

            // ACOS
            float Variable_74; // ACOS output 0
            Variable_74 = FVoxelNodeFunctions::Acos(Variable_75);

            // /
            float Variable_71; // / output 0
            Variable_71 = Variable_74 / ConstantsCache.Variable_67;

            // 1 - X
            float Variable_69; // 1 - X output 0
            Variable_69 = 1 - Variable_71;

            // Min (float)
            float Variable_68; // Min (float) output 0
            Variable_68 = FVoxelNodeFunctions::Min<float>(Variable_71, Variable_69);

            // /
            float Variable_70; // / output 0
            Variable_70 = Variable_68 / float(0.5f);

            // 1 - X
            float Variable_77; // 1 - X output 0
            Variable_77 = 1 - Variable_70;

            // *
            float Variable_78; // * output 0
            Variable_78 = Variable_77 * float(20.0f);

            // /
            float Variable_94; // / output 0
            Variable_94 = Variable_78 / ConstantsCache.Variable_95;

            // RiverCurve
            float Variable_64; // RiverCurve output 0
            Variable_64 = RiverMask.Eval(Variable_94);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_89; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_89 = FMath::Clamp<float>(Variable_64, -1.000000, 1.000000);

            // Min (float)
            float Variable_81; // Min (float) output 0
            Variable_81 = FVoxelNodeFunctions::Min<float>(Variable_89, float(0.0f));

            // *
            float Variable_82; // * output 0
            Variable_82 = Variable_81 * float(-1.0f);

            // *
            float Variable_83; // * output 0
            Variable_83 = Variable_63 * Variable_82;

            // 1 - X
            float Variable_84; // 1 - X output 0
            Variable_84 = 1 - Variable_82;

            // -
            float Variable_85; // - output 0
            Variable_85 = Variable_83 - Variable_84;

            // 1 - X
            float Variable_56; // 1 - X output 0
            Variable_56 = 1 - Variable_87;

            // PlainsNoiseStrengthCurve
            float Variable_62; // PlainsNoiseStrengthCurve output 0
            Variable_62 = PlainsNoiseStrength.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_88; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_88 = FMath::Clamp<float>(Variable_62, 0.000000, 1.000000);

            // *
            float Variable_57; // * output 0
            Variable_57 = Variable_85 * ConstantsCache.Variable_58 * Variable_56 * Variable_88;

            // Max (float)
            float Variable_80; // Max (float) output 0
            Variable_80 = FVoxelNodeFunctions::Max<float>(Variable_89, float(0.0f));

            // *
            float Variable_65; // * output 0
            Variable_65 = Variable_80 * float(-1.0f) * ConstantsCache.Variable_66;

            // +
            float Variable_33; // + output 0
            Variable_33 = Variable_39 + Variable_42 + Variable_48 + Variable_55 + Variable_57 + Variable_65;

            // *
            float Variable_93; // * output 0
            Variable_93 = Variable_33 * ConstantsCache.Variable_90;

            // -
            float Variable_32; // - output 0
            Variable_32 = ConstantsCache.Variable_91 - Variable_93;

            // -
            float Variable_4; // - output 0
            Variable_4 = Variable_32 - Variable_30;

            // -
            float Variable_7; // - output 0
            Variable_7 = Variable_30 - ConstantsCache.Variable_6;

            // Max (float)
            float Variable_8; // Max (float) output 0
            Variable_8 = FVoxelNodeFunctions::Max<float>(Variable_4, Variable_7);

            // -
            float Variable_19; // - output 0
            Variable_19 = Variable_8 - float(1.0f);

            // Max (float)
            float Variable_18; // Max (float) output 0
            Variable_18 = FVoxelNodeFunctions::Max<float>(Variable_35, float(0.0f));

            // *
            float Variable_20; // * output 0
            Variable_20 = Variable_18 * ConstantsCache.Variable_22;

            // Min (float)
            float Variable_21; // Min (float) output 0
            Variable_21 = FVoxelNodeFunctions::Min<float>(Variable_20, float(1.0f));

            // *
            float Variable_16; // * output 0
            Variable_16 = Variable_19 * Variable_21;

            // +
            float Variable_17; // + output 0
            Variable_17 = Variable_16 + float(1.0f);

            GraphOutputs.Value = Variable_17;
        }

        void Function0_Compute(FVoxelGraphOutputs& GraphOutputs, const FVoxelContext& Context) const
        {
            // Z
            float Variable_12; // Z output 0
            Variable_12 = Context.Z;

            // X
            float Variable_0; // X output 0
            Variable_0 = Context.X;

            // Y
            float Variable_1; // Y output 0
            Variable_1 = Context.Y;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Variable_0, Variable_1, Variable_2);

            // +
            float Variable_30; // + output 0
            Variable_30 = Variable_3 + float(0.001f);

            // /
            float Variable_13; // / output 0
            Variable_13 = Variable_12 / Variable_30;

            // ACOS
            float Variable_14; // ACOS output 0
            Variable_14 = FVoxelNodeFunctions::Acos(Variable_13);

            // /
            float Variable_10; // / output 0
            Variable_10 = Variable_14 / ConstantsCache.Variable_98;

            // 1 - X
            float Variable_11; // 1 - X output 0
            Variable_11 = 1 - Variable_10;

            // Min (float)
            float Variable_9; // Min (float) output 0
            Variable_9 = FVoxelNodeFunctions::Min<float>(Variable_10, Variable_11);

            // -
            float Variable_15; // - output 0
            Variable_15 = Variable_9 - ConstantsCache.Variable_36;

            // /
            float Variable_35; // / output 0
            Variable_35 = Variable_15 / ConstantsCache.Variable_37;

            // 1 - X
            float Variable_34; // 1 - X output 0
            Variable_34 = 1 - Variable_35;

            // RingCurve
            float Variable_38; // RingCurve output 0
            Variable_38 = RingShape.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_86; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_86 = FMath::Clamp<float>(Variable_38, 0.000000, 1.000000);

            // *
            float Variable_39; // * output 0
            Variable_39 = Variable_86 * ConstantsCache.Variable_40;

            // *
            float Variable_27; // * output 0
            Variable_27 = ConstantsCache.Variable_92 * Variable_10;

            // *
            float Variable_44; // * output 0
            Variable_44 = Variable_27 * ConstantsCache.Variable_46;

            // Y
            float Variable_29; // Y output 0
            Variable_29 = Context.Y;

            // X
            float Variable_24; // X output 0
            Variable_24 = Context.X;

            // ATAN2
            float Variable_23; // ATAN2 output 0
            Variable_23 = FVoxelNodeFunctions::Atan2(Variable_29, Variable_24);

            // /
            float Variable_26; // / output 0
            Variable_26 = Variable_23 / ConstantsCache.Variable_25;

            // *
            float Variable_28; // * output 0
            Variable_28 = ConstantsCache.Variable_92 * Variable_26;

            // *
            float Variable_45; // * output 0
            Variable_45 = Variable_28 * ConstantsCache.Variable_46;

            // 2D Simplex Noise Fractal
            float Variable_41; // 2D Simplex Noise Fractal output 0
            Variable_41 = _2D_Simplex_Noise_Fractal_15560_Noise.GetSimplexFractal(Variable_44, Variable_45);

            // *
            float Variable_42; // * output 0
            Variable_42 = Variable_41 * ConstantsCache.Variable_43;

            // *
            float Variable_50; // * output 0
            Variable_50 = Variable_27 * ConstantsCache.Variable_52;

            // *
            float Variable_51; // * output 0
            Variable_51 = Variable_28 * ConstantsCache.Variable_52;

            // 2D Simplex Noise Fractal
            float Variable_47; // 2D Simplex Noise Fractal output 0
            Variable_47 = _2D_Simplex_Noise_Fractal_15561_Noise.GetSimplexFractal(Variable_50, Variable_51);

            // MountainsCurve
            float Variable_53; // MountainsCurve output 0
            Variable_53 = MoutainsMask.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_87; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_87 = FMath::Clamp<float>(Variable_53, 0.000000, 1.000000);

            // *
            float Variable_48; // * output 0
            Variable_48 = Variable_47 * ConstantsCache.Variable_49 * Variable_87;

            // 2D Perlin Noise
            float Variable_54; // 2D Perlin Noise output 0
            Variable_54 = _2D_Perlin_Noise_7430_Noise.GetPerlin(Variable_50, Variable_51);

            // *
            float Variable_55; // * output 0
            Variable_55 = ConstantsCache.Variable_49 * Variable_87 * Variable_54 * float(0.1f);

            // *
            float Variable_59; // * output 0
            Variable_59 = Variable_27 * ConstantsCache.Variable_61;

            // *
            float Variable_60; // * output 0
            Variable_60 = Variable_28 * ConstantsCache.Variable_61;

            // 2D Simplex Noise
            float Variable_63; // 2D Simplex Noise output 0
            Variable_63 = _2D_Simplex_Noise_8748_Noise.GetSimplex(Variable_59, Variable_60);

            // Z
            float Variable_72; // Z output 0
            Variable_72 = Context.Z;

            // /
            float Variable_73; // / output 0
            Variable_73 = Variable_72 / Variable_30;

            // 2D Simplex Noise
            float Variable_79; // 2D Simplex Noise output 0
            Variable_79 = _2D_Simplex_Noise_8747_Noise.GetSimplex(Variable_28, Variable_28);

            // *
            float Variable_76; // * output 0
            Variable_76 = Variable_79 * float(0.1f);

            // +
            float Variable_75; // + output 0
            Variable_75 = Variable_73 + Variable_76;

            // ACOS
            float Variable_74; // ACOS output 0
            Variable_74 = FVoxelNodeFunctions::Acos(Variable_75);

            // /
            float Variable_71; // / output 0
            Variable_71 = Variable_74 / ConstantsCache.Variable_67;

            // 1 - X
            float Variable_69; // 1 - X output 0
            Variable_69 = 1 - Variable_71;

            // Min (float)
            float Variable_68; // Min (float) output 0
            Variable_68 = FVoxelNodeFunctions::Min<float>(Variable_71, Variable_69);

            // /
            float Variable_70; // / output 0
            Variable_70 = Variable_68 / float(0.5f);

            // 1 - X
            float Variable_77; // 1 - X output 0
            Variable_77 = 1 - Variable_70;

            // *
            float Variable_78; // * output 0
            Variable_78 = Variable_77 * float(20.0f);

            // /
            float Variable_94; // / output 0
            Variable_94 = Variable_78 / ConstantsCache.Variable_95;

            // RiverCurve
            float Variable_64; // RiverCurve output 0
            Variable_64 = RiverMask.Eval(Variable_94);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_89; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_89 = FMath::Clamp<float>(Variable_64, -1.000000, 1.000000);

            // Min (float)
            float Variable_81; // Min (float) output 0
            Variable_81 = FVoxelNodeFunctions::Min<float>(Variable_89, float(0.0f));

            // *
            float Variable_82; // * output 0
            Variable_82 = Variable_81 * float(-1.0f);

            // *
            float Variable_83; // * output 0
            Variable_83 = Variable_63 * Variable_82;

            // 1 - X
            float Variable_84; // 1 - X output 0
            Variable_84 = 1 - Variable_82;

            // -
            float Variable_85; // - output 0
            Variable_85 = Variable_83 - Variable_84;

            // 1 - X
            float Variable_56; // 1 - X output 0
            Variable_56 = 1 - Variable_87;

            // PlainsNoiseStrengthCurve
            float Variable_62; // PlainsNoiseStrengthCurve output 0
            Variable_62 = PlainsNoiseStrength.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_88; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_88 = FMath::Clamp<float>(Variable_62, 0.000000, 1.000000);

            // *
            float Variable_57; // * output 0
            Variable_57 = Variable_85 * ConstantsCache.Variable_58 * Variable_56 * Variable_88;

            // Max (float)
            float Variable_80; // Max (float) output 0
            Variable_80 = FVoxelNodeFunctions::Max<float>(Variable_89, float(0.0f));

            // *
            float Variable_65; // * output 0
            Variable_65 = Variable_80 * float(-1.0f) * ConstantsCache.Variable_66;

            // +
            float Variable_33; // + output 0
            Variable_33 = Variable_39 + Variable_42 + Variable_48 + Variable_55 + Variable_57 + Variable_65;

            // *
            float Variable_93; // * output 0
            Variable_93 = Variable_33 * ConstantsCache.Variable_90;

            // -
            float Variable_32; // - output 0
            Variable_32 = ConstantsCache.Variable_91 - Variable_93;

            // -
            float Variable_4; // - output 0
            Variable_4 = Variable_32 - Variable_30;

            // -
            float Variable_7; // - output 0
            Variable_7 = Variable_30 - ConstantsCache.Variable_6;

            // Max (float)
            float Variable_8; // Max (float) output 0
            Variable_8 = FVoxelNodeFunctions::Max<float>(Variable_4, Variable_7);

            // -
            float Variable_19; // - output 0
            Variable_19 = Variable_8 - float(1.0f);

            // Max (float)
            float Variable_18; // Max (float) output 0
            Variable_18 = FVoxelNodeFunctions::Max<float>(Variable_35, float(0.0f));

            // *
            float Variable_20; // * output 0
            Variable_20 = Variable_18 * ConstantsCache.Variable_22;

            // Min (float)
            float Variable_21; // Min (float) output 0
            Variable_21 = FVoxelNodeFunctions::Min<float>(Variable_20, float(1.0f));

            // *
            float Variable_16; // * output 0
            Variable_16 = Variable_19 * Variable_21;

            // +
            float Variable_17; // + output 0
            Variable_17 = Variable_16 + float(1.0f);

            GraphOutputs.Value = Variable_17;
        }

    };
    struct FLocalComputeStruct_LocalMaterial_LOD0
    {
        struct FVoxelGraphOutputs
        {
            FVoxelMaterial& Material;
        };
        struct FVoxelConstantsCache
        {
            float Variable_61; // PlainsColorLow output 0
            float Variable_62; // PlainsColorLow output 1
            float Variable_63; // PlainsColorLow output 2
            float Variable_64; // PlainsColorLow output 3
            float Variable_15; // RingEdgesHardness = 10.0 output 0
            float Variable_18; // PI.3.141593 output 0
            float Variable_25; // Width in Degrees = 50.0 output 0
            float Variable_69; // RiverColor output 0
            float Variable_70; // RiverColor output 1
            float Variable_71; // RiverColor output 2
            float Variable_72; // RiverColor output 3
            float Variable_92; // BeachColor output 0
            float Variable_93; // BeachColor output 1
            float Variable_94; // BeachColor output 2
            float Variable_95; // BeachColor output 3
            float Variable_33; // MountainsNoiseFrequency = 0.2 output 0
            float Variable_36; // MountainsColorHigh output 0
            float Variable_37; // MountainsColorHigh output 1
            float Variable_38; // MountainsColorHigh output 2
            float Variable_39; // MountainsColorHigh output 3
            float Variable_40; // MountainsColorLowLow output 0
            float Variable_41; // MountainsColorLowLow output 1
            float Variable_42; // MountainsColorLowLow output 2
            float Variable_43; // MountainsColorLowLow output 3
            float Variable_46; // MountainsColorLowHigh output 0
            float Variable_47; // MountainsColorLowHigh output 1
            float Variable_48; // MountainsColorLowHigh output 2
            float Variable_49; // MountainsColorLowHigh output 3
            float Variable_52; // PlainsNoiseFrequency = 0.2 output 0
            float Variable_54; // PlainsColorHigh output 0
            float Variable_55; // PlainsColorHigh output 1
            float Variable_56; // PlainsColorHigh output 2
            float Variable_57; // PlainsColorHigh output 3
            float Variable_4; // Radius = 7000.0 output 0
            float Variable_68; // PI.3.141593 output 0
            float Variable_104; // RiverWidth = 1.0 output 0
            float Variable_100; // Scale = 10.0 output 0
            float Variable_108; // Thickness = 500.0 output 0
            float Variable_110; // PI.3.141593 output 0
            float Variable_112; // RingOuterColor output 0
            float Variable_113; // RingOuterColor output 1
            float Variable_114; // RingOuterColor output 2
            float Variable_115; // RingOuterColor output 3
            float Variable_109; // * output 0
            float Variable_29; // / output 0
            float Variable_101; // * output 0
            float Variable_102; // / output 0
            float Variable_28; // - output 0
            float Variable_107; // + output 0
        };
        struct FVoxelCache
        {
            float Variable_0; // X output 0
            float Variable_17; // X output 0
            float Variable_1; // Y output 0
            float Variable_23; // Y output 0
            float Variable_16; // ATAN2 output 0
            float Variable_19; // / output 0
            float Variable_22; // * output 0
            float Variable_51; // * output 0
            float Variable_85; // 2D Simplex Noise output 0
            float Variable_82; // * output 0
            float Variable_32; // * output 0
        };

        FLocalComputeStruct_LocalMaterial_LOD0(const float& InScale, const float& InPlainsNoiseHeight, const float& InRingEdgesHardness, const float& InWidth_in_Degrees, const float& InRiverDepth, const float& InThickness, const float& InBaseHeight, const float& InBaseNoiseHeight, const float& InBaseNoiseFrquency, const float& InMountainsNoiseHeight, const float& InRadius, const float& InRiverWidth, const float& InPlainsNoiseFrequency, const float& InMountainsNoiseFrequency, const FRichCurve& InRingShape, const FRichCurve& InMoutainsMask, const FRichCurve& InRiverMask, const FRichCurve& InPlainsNoiseStrength, const FLinearColor& InPlainsColorLow, const FLinearColor& InRiverColor, const FLinearColor& InBeachColor, const FLinearColor& InMountainsColorHigh, const FLinearColor& InMountainsColorLowLow, const FLinearColor& InMountainsColorLowHigh, const FLinearColor& InPlainsColorHigh, const FLinearColor& InRingOuterColor)
            : Scale(InScale)
            , PlainsNoiseHeight(InPlainsNoiseHeight)
            , RingEdgesHardness(InRingEdgesHardness)
            , Width_in_Degrees(InWidth_in_Degrees)
            , RiverDepth(InRiverDepth)
            , Thickness(InThickness)
            , BaseHeight(InBaseHeight)
            , BaseNoiseHeight(InBaseNoiseHeight)
            , BaseNoiseFrquency(InBaseNoiseFrquency)
            , MountainsNoiseHeight(InMountainsNoiseHeight)
            , Radius(InRadius)
            , RiverWidth(InRiverWidth)
            , PlainsNoiseFrequency(InPlainsNoiseFrequency)
            , MountainsNoiseFrequency(InMountainsNoiseFrequency)
            , RingShape(InRingShape)
            , MoutainsMask(InMoutainsMask)
            , RiverMask(InRiverMask)
            , PlainsNoiseStrength(InPlainsNoiseStrength)
            , PlainsColorLow(InPlainsColorLow)
            , RiverColor(InRiverColor)
            , BeachColor(InBeachColor)
            , MountainsColorHigh(InMountainsColorHigh)
            , MountainsColorLowLow(InMountainsColorLowLow)
            , MountainsColorLowHigh(InMountainsColorLowHigh)
            , PlainsColorHigh(InPlainsColorHigh)
            , RingOuterColor(InRingOuterColor)
        {
        }

        void Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            FVoxelCache Cache;

            {
            }

            Function0_Init(InitStruct);

            {
                // PlainsColorLow
                ConstantsCache.Variable_61 = PlainsColorLow.R;
                ConstantsCache.Variable_62 = PlainsColorLow.G;
                ConstantsCache.Variable_63 = PlainsColorLow.B;
                ConstantsCache.Variable_64 = PlainsColorLow.A;

                // RingEdgesHardness = 10.0
                ConstantsCache.Variable_15 = RingEdgesHardness;

                // PI.3.141593
                ConstantsCache.Variable_18 = 3.141593;

                // Width in Degrees = 50.0
                ConstantsCache.Variable_25 = Width_in_Degrees;

                // RiverColor
                ConstantsCache.Variable_69 = RiverColor.R;
                ConstantsCache.Variable_70 = RiverColor.G;
                ConstantsCache.Variable_71 = RiverColor.B;
                ConstantsCache.Variable_72 = RiverColor.A;

                // BeachColor
                ConstantsCache.Variable_92 = BeachColor.R;
                ConstantsCache.Variable_93 = BeachColor.G;
                ConstantsCache.Variable_94 = BeachColor.B;
                ConstantsCache.Variable_95 = BeachColor.A;

                // MountainsNoiseFrequency = 0.2
                ConstantsCache.Variable_33 = MountainsNoiseFrequency;

                // MountainsColorHigh
                ConstantsCache.Variable_36 = MountainsColorHigh.R;
                ConstantsCache.Variable_37 = MountainsColorHigh.G;
                ConstantsCache.Variable_38 = MountainsColorHigh.B;
                ConstantsCache.Variable_39 = MountainsColorHigh.A;

                // MountainsColorLowLow
                ConstantsCache.Variable_40 = MountainsColorLowLow.R;
                ConstantsCache.Variable_41 = MountainsColorLowLow.G;
                ConstantsCache.Variable_42 = MountainsColorLowLow.B;
                ConstantsCache.Variable_43 = MountainsColorLowLow.A;

                // MountainsColorLowHigh
                ConstantsCache.Variable_46 = MountainsColorLowHigh.R;
                ConstantsCache.Variable_47 = MountainsColorLowHigh.G;
                ConstantsCache.Variable_48 = MountainsColorLowHigh.B;
                ConstantsCache.Variable_49 = MountainsColorLowHigh.A;

                // PlainsNoiseFrequency = 0.2
                ConstantsCache.Variable_52 = PlainsNoiseFrequency;

                // PlainsColorHigh
                ConstantsCache.Variable_54 = PlainsColorHigh.R;
                ConstantsCache.Variable_55 = PlainsColorHigh.G;
                ConstantsCache.Variable_56 = PlainsColorHigh.B;
                ConstantsCache.Variable_57 = PlainsColorHigh.A;

                // Radius = 7000.0
                ConstantsCache.Variable_4 = Radius;

                // PI.3.141593
                ConstantsCache.Variable_68 = 3.141593;

                // RiverWidth = 1.0
                ConstantsCache.Variable_104 = RiverWidth;

                // Scale = 10.0
                ConstantsCache.Variable_100 = Scale;

                // Thickness = 500.0
                ConstantsCache.Variable_108 = Thickness;

                // PI.3.141593
                ConstantsCache.Variable_110 = 3.141593;

                // RingOuterColor
                ConstantsCache.Variable_112 = RingOuterColor.R;
                ConstantsCache.Variable_113 = RingOuterColor.G;
                ConstantsCache.Variable_114 = RingOuterColor.B;
                ConstantsCache.Variable_115 = RingOuterColor.A;

                // *
                ConstantsCache.Variable_109 = ConstantsCache.Variable_108 * ConstantsCache.Variable_100;

                // /
                ConstantsCache.Variable_29 = ConstantsCache.Variable_25 / float(360.0f);

                // *
                ConstantsCache.Variable_101 = ConstantsCache.Variable_4 * ConstantsCache.Variable_100;

                // /
                ConstantsCache.Variable_102 = ConstantsCache.Variable_101 / ConstantsCache.Variable_100;

                // -
                ConstantsCache.Variable_28 = float(0.5f) - ConstantsCache.Variable_29;

                // +
                ConstantsCache.Variable_107 = ConstantsCache.Variable_101 + ConstantsCache.Variable_109 + float(-5.0f);

            }
        }
        void ComputeX(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_X_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXY(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XY_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXYZ(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XYZ_Compute(GraphOutputs, Cache, Context);
        }
        void Get(const FVoxelContext&Context, FVoxelMaterial& Material) const
        {
            FVoxelGraphOutputs GraphOutputs{Material};
            Function0_Compute(GraphOutputs, Context);
        }

    private:
        FVoxelConstantsCache ConstantsCache;
        FastNoise _2D_Simplex_Noise_8749_Noise;
        FastNoise _2D_Simplex_Noise_8750_Noise;
        FastNoise _2D_Perlin_Noise_7431_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15562_Noise;

        const float& Scale;
        const float& PlainsNoiseHeight;
        const float& RingEdgesHardness;
        const float& Width_in_Degrees;
        const float& RiverDepth;
        const float& Thickness;
        const float& BaseHeight;
        const float& BaseNoiseHeight;
        const float& BaseNoiseFrquency;
        const float& MountainsNoiseHeight;
        const float& Radius;
        const float& RiverWidth;
        const float& PlainsNoiseFrequency;
        const float& MountainsNoiseFrequency;
        const FRichCurve& RingShape;
        const FRichCurve& MoutainsMask;
        const FRichCurve& RiverMask;
        const FRichCurve& PlainsNoiseStrength;
        const FLinearColor& PlainsColorLow;
        const FLinearColor& RiverColor;
        const FLinearColor& BeachColor;
        const FLinearColor& MountainsColorHigh;
        const FLinearColor& MountainsColorLowLow;
        const FLinearColor& MountainsColorLowHigh;
        const FLinearColor& PlainsColorHigh;
        const FLinearColor& RingOuterColor;

        ///////////////////////////////////////////////////////////////////////
        //////////////////////////// Init functions ///////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8750_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_8750_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_8750_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8749_Noise.SetSeed(Seed(1000));
            _2D_Simplex_Noise_8749_Noise.SetFrequency(0.001);
            _2D_Simplex_Noise_8749_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Perlin Noise
            _2D_Perlin_Noise_7431_Noise.SetSeed(Seed(1338));
            _2D_Perlin_Noise_7431_Noise.SetFrequency(0.1);
            _2D_Perlin_Noise_7431_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15562_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15562_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15562_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15562_Noise.SetFractalOctaves(8);
            _2D_Simplex_Noise_Fractal_15562_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15562_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15562_Noise.SetFractalType(FastNoise::FractalType::FBM);

        }

        ///////////////////////////////////////////////////////////////////////
        ////////////////////////// Compute functions //////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_X_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // X
            Cache.Variable_0 = Context.X;

            // X
            Cache.Variable_17 = Context.X;

        }

        void Function0_XY_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // Y
            Cache.Variable_1 = Context.Y;

            // Y
            Cache.Variable_23 = Context.Y;

            // ATAN2
            Cache.Variable_16 = FVoxelNodeFunctions::Atan2(Cache.Variable_23, Cache.Variable_17);

            // /
            Cache.Variable_19 = Cache.Variable_16 / ConstantsCache.Variable_18;

            // *
            Cache.Variable_22 = ConstantsCache.Variable_102 * Cache.Variable_19;

            // *
            Cache.Variable_51 = Cache.Variable_22 * ConstantsCache.Variable_52;

            // 2D Simplex Noise
            Cache.Variable_85 = _2D_Simplex_Noise_8749_Noise.GetSimplex(Cache.Variable_22, Cache.Variable_22);

            // *
            Cache.Variable_82 = Cache.Variable_85 * float(0.1f);

            // *
            Cache.Variable_32 = Cache.Variable_22 * ConstantsCache.Variable_33;

        }

        void Function0_XYZ_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // Z
            float Variable_8; // Z output 0
            Variable_8 = Context.Z;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Cache.Variable_0, Cache.Variable_1, Variable_2);

            // +
            float Variable_24; // + output 0
            Variable_24 = Variable_3 + float(0.001f);

            // /
            float Variable_9; // / output 0
            Variable_9 = Variable_8 / Variable_24;

            // ACOS
            float Variable_10; // ACOS output 0
            Variable_10 = FVoxelNodeFunctions::Acos(Variable_9);

            // /
            float Variable_6; // / output 0
            Variable_6 = Variable_10 / ConstantsCache.Variable_110;

            // *
            float Variable_21; // * output 0
            Variable_21 = ConstantsCache.Variable_102 * Variable_6;

            // *
            float Variable_50; // * output 0
            Variable_50 = Variable_21 * ConstantsCache.Variable_52;

            // 2D Simplex Noise
            float Variable_58; // 2D Simplex Noise output 0
            Variable_58 = _2D_Simplex_Noise_8750_Noise.GetSimplex(Variable_50, Cache.Variable_51);

            // Z
            float Variable_77; // Z output 0
            Variable_77 = Context.Z;

            // /
            float Variable_78; // / output 0
            Variable_78 = Variable_77 / Variable_24;

            // +
            float Variable_81; // + output 0
            Variable_81 = Variable_78 + Cache.Variable_82;

            // ACOS
            float Variable_79; // ACOS output 0
            Variable_79 = FVoxelNodeFunctions::Acos(Variable_81);

            // /
            float Variable_76; // / output 0
            Variable_76 = Variable_79 / ConstantsCache.Variable_68;

            // 1 - X
            float Variable_74; // 1 - X output 0
            Variable_74 = 1 - Variable_76;

            // Min (float)
            float Variable_73; // Min (float) output 0
            Variable_73 = FVoxelNodeFunctions::Min<float>(Variable_76, Variable_74);

            // /
            float Variable_75; // / output 0
            Variable_75 = Variable_73 / float(0.5f);

            // 1 - X
            float Variable_83; // 1 - X output 0
            Variable_83 = 1 - Variable_75;

            // *
            float Variable_84; // * output 0
            Variable_84 = Variable_83 * float(20.0f);

            // /
            float Variable_103; // / output 0
            Variable_103 = Variable_84 / ConstantsCache.Variable_104;

            // RiverCurve
            float Variable_67; // RiverCurve output 0
            Variable_67 = RiverMask.Eval(Variable_103);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_99; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_99 = FMath::Clamp<float>(Variable_67, -1.000000, 1.000000);

            // Min (float)
            float Variable_86; // Min (float) output 0
            Variable_86 = FVoxelNodeFunctions::Min<float>(Variable_99, float(0.0f));

            // *
            float Variable_87; // * output 0
            Variable_87 = Variable_86 * float(-1.0f);

            // *
            float Variable_88; // * output 0
            Variable_88 = Variable_58 * Variable_87;

            // 1 - X
            float Variable_89; // 1 - X output 0
            Variable_89 = 1 - Variable_87;

            // -
            float Variable_90; // - output 0
            Variable_90 = Variable_88 - Variable_89;

            // BlendColors.Clamp
            float Variable_53; // BlendColors.Clamp output 0
            Variable_53 = FVoxelNodeFunctions::Clamp(Variable_90, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_128; // BlendColors.Lerp output 0
            Variable_128 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_61, ConstantsCache.Variable_54, Variable_53);

            // *
            float Variable_97; // * output 0
            Variable_97 = Variable_99 * float(10.0f);

            // BlendColors.Clamp
            float Variable_80; // BlendColors.Clamp output 0
            Variable_80 = FVoxelNodeFunctions::Clamp(Variable_97, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_136; // BlendColors.Lerp output 0
            Variable_136 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_92, ConstantsCache.Variable_69, Variable_80);

            // +
            float Variable_91; // + output 0
            Variable_91 = Variable_99 + float(0.3f);

            // BlendColors.Clamp
            float Variable_60; // BlendColors.Clamp output 0
            Variable_60 = FVoxelNodeFunctions::Clamp(Variable_91, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_132; // BlendColors.Lerp output 0
            Variable_132 = FVoxelNodeFunctions::Lerp(Variable_128, Variable_136, Variable_60);

            // *
            float Variable_31; // * output 0
            Variable_31 = Variable_21 * ConstantsCache.Variable_33;

            // 2D Perlin Noise
            float Variable_44; // 2D Perlin Noise output 0
            Variable_44 = _2D_Perlin_Noise_7431_Noise.GetPerlin(Variable_31, Cache.Variable_32);

            // BlendColors.Clamp
            float Variable_35; // BlendColors.Clamp output 0
            Variable_35 = FVoxelNodeFunctions::Clamp(Variable_44, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_120; // BlendColors.Lerp output 0
            Variable_120 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_40, ConstantsCache.Variable_46, Variable_35);

            // 2D Simplex Noise Fractal
            float Variable_30; // 2D Simplex Noise Fractal output 0
            Variable_30 = _2D_Simplex_Noise_Fractal_15562_Noise.GetSimplexFractal(Variable_31, Cache.Variable_32);

            // BlendColors.Clamp
            float Variable_20; // BlendColors.Clamp output 0
            Variable_20 = FVoxelNodeFunctions::Clamp(Variable_30, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_116; // BlendColors.Lerp output 0
            Variable_116 = FVoxelNodeFunctions::Lerp(Variable_120, ConstantsCache.Variable_36, Variable_20);

            // 1 - X
            float Variable_7; // 1 - X output 0
            Variable_7 = 1 - Variable_6;

            // Min (float)
            float Variable_5; // Min (float) output 0
            Variable_5 = FVoxelNodeFunctions::Min<float>(Variable_6, Variable_7);

            // -
            float Variable_11; // - output 0
            Variable_11 = Variable_5 - ConstantsCache.Variable_28;

            // /
            float Variable_27; // / output 0
            Variable_27 = Variable_11 / ConstantsCache.Variable_29;

            // 1 - X
            float Variable_26; // 1 - X output 0
            Variable_26 = 1 - Variable_27;

            // MountainsCurve
            float Variable_34; // MountainsCurve output 0
            Variable_34 = MoutainsMask.Eval(Variable_26);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_98; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_98 = FMath::Clamp<float>(Variable_34, 0.000000, 1.000000);

            // *
            float Variable_59; // * output 0
            Variable_59 = Variable_98 * float(3.0f);

            // Max (float)
            float Variable_65; // Max (float) output 0
            Variable_65 = FVoxelNodeFunctions::Max<float>(Variable_90, float(0.0f));

            // -
            float Variable_66; // - output 0
            Variable_66 = Variable_59 - Variable_65;

            // BlendColors.Clamp
            float Variable_45; // BlendColors.Clamp output 0
            Variable_45 = FVoxelNodeFunctions::Clamp(Variable_66, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_124; // BlendColors.Lerp output 0
            Variable_124 = FVoxelNodeFunctions::Lerp(Variable_132, Variable_116, Variable_45);

            // Max (float)
            float Variable_12; // Max (float) output 0
            Variable_12 = FVoxelNodeFunctions::Max<float>(Variable_27, float(0.0f));

            // *
            float Variable_13; // * output 0
            Variable_13 = Variable_12 * ConstantsCache.Variable_15;

            // Min (float)
            float Variable_14; // Min (float) output 0
            Variable_14 = FVoxelNodeFunctions::Min<float>(Variable_13, float(1.0f));

            // -
            float Variable_111; // - output 0
            Variable_111 = ConstantsCache.Variable_107 - Variable_24;

            // Clamp
            float Variable_105; // Clamp output 0
            Variable_105 = FVoxelNodeFunctions::Clamp(Variable_111, float(0.0f), float(1.0f));

            // Min (float)
            float Variable_106; // Min (float) output 0
            Variable_106 = FVoxelNodeFunctions::Min<float>(Variable_14, Variable_105);

            // BlendColors.Clamp
            float Variable_96; // BlendColors.Clamp output 0
            Variable_96 = FVoxelNodeFunctions::Clamp(Variable_106, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_140; // BlendColors.Lerp output 0
            Variable_140 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_112, Variable_124, Variable_96);

            // BlendColors.Lerp
            float Variable_129; // BlendColors.Lerp output 0
            Variable_129 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_62, ConstantsCache.Variable_55, Variable_53);

            // BlendColors.Lerp
            float Variable_137; // BlendColors.Lerp output 0
            Variable_137 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_93, ConstantsCache.Variable_70, Variable_80);

            // BlendColors.Lerp
            float Variable_133; // BlendColors.Lerp output 0
            Variable_133 = FVoxelNodeFunctions::Lerp(Variable_129, Variable_137, Variable_60);

            // BlendColors.Lerp
            float Variable_121; // BlendColors.Lerp output 0
            Variable_121 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_41, ConstantsCache.Variable_47, Variable_35);

            // BlendColors.Lerp
            float Variable_117; // BlendColors.Lerp output 0
            Variable_117 = FVoxelNodeFunctions::Lerp(Variable_121, ConstantsCache.Variable_37, Variable_20);

            // BlendColors.Lerp
            float Variable_125; // BlendColors.Lerp output 0
            Variable_125 = FVoxelNodeFunctions::Lerp(Variable_133, Variable_117, Variable_45);

            // BlendColors.Lerp
            float Variable_141; // BlendColors.Lerp output 0
            Variable_141 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_113, Variable_125, Variable_96);

            // BlendColors.Lerp
            float Variable_130; // BlendColors.Lerp output 0
            Variable_130 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_63, ConstantsCache.Variable_56, Variable_53);

            // BlendColors.Lerp
            float Variable_138; // BlendColors.Lerp output 0
            Variable_138 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_94, ConstantsCache.Variable_71, Variable_80);

            // BlendColors.Lerp
            float Variable_134; // BlendColors.Lerp output 0
            Variable_134 = FVoxelNodeFunctions::Lerp(Variable_130, Variable_138, Variable_60);

            // BlendColors.Lerp
            float Variable_122; // BlendColors.Lerp output 0
            Variable_122 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_42, ConstantsCache.Variable_48, Variable_35);

            // BlendColors.Lerp
            float Variable_118; // BlendColors.Lerp output 0
            Variable_118 = FVoxelNodeFunctions::Lerp(Variable_122, ConstantsCache.Variable_38, Variable_20);

            // BlendColors.Lerp
            float Variable_126; // BlendColors.Lerp output 0
            Variable_126 = FVoxelNodeFunctions::Lerp(Variable_134, Variable_118, Variable_45);

            // BlendColors.Lerp
            float Variable_142; // BlendColors.Lerp output 0
            Variable_142 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_114, Variable_126, Variable_96);

            // BlendColors.Lerp
            float Variable_131; // BlendColors.Lerp output 0
            Variable_131 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_64, ConstantsCache.Variable_57, Variable_53);

            // BlendColors.Lerp
            float Variable_139; // BlendColors.Lerp output 0
            Variable_139 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_95, ConstantsCache.Variable_72, Variable_80);

            // BlendColors.Lerp
            float Variable_135; // BlendColors.Lerp output 0
            Variable_135 = FVoxelNodeFunctions::Lerp(Variable_131, Variable_139, Variable_60);

            // BlendColors.Lerp
            float Variable_123; // BlendColors.Lerp output 0
            Variable_123 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_43, ConstantsCache.Variable_49, Variable_35);

            // BlendColors.Lerp
            float Variable_119; // BlendColors.Lerp output 0
            Variable_119 = FVoxelNodeFunctions::Lerp(Variable_123, ConstantsCache.Variable_39, Variable_20);

            // BlendColors.Lerp
            float Variable_127; // BlendColors.Lerp output 0
            Variable_127 = FVoxelNodeFunctions::Lerp(Variable_135, Variable_119, Variable_45);

            // BlendColors.Lerp
            float Variable_143; // BlendColors.Lerp output 0
            Variable_143 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_115, Variable_127, Variable_96);

            GraphOutputs.Material.SetColor(FLinearColor(Variable_140, Variable_141, Variable_142, Variable_143));
        }

        void Function0_Compute(FVoxelGraphOutputs& GraphOutputs, const FVoxelContext& Context) const
        {
            // Z
            float Variable_8; // Z output 0
            Variable_8 = Context.Z;

            // X
            float Variable_0; // X output 0
            Variable_0 = Context.X;

            // Y
            float Variable_1; // Y output 0
            Variable_1 = Context.Y;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Variable_0, Variable_1, Variable_2);

            // +
            float Variable_24; // + output 0
            Variable_24 = Variable_3 + float(0.001f);

            // /
            float Variable_9; // / output 0
            Variable_9 = Variable_8 / Variable_24;

            // ACOS
            float Variable_10; // ACOS output 0
            Variable_10 = FVoxelNodeFunctions::Acos(Variable_9);

            // /
            float Variable_6; // / output 0
            Variable_6 = Variable_10 / ConstantsCache.Variable_110;

            // *
            float Variable_21; // * output 0
            Variable_21 = ConstantsCache.Variable_102 * Variable_6;

            // *
            float Variable_50; // * output 0
            Variable_50 = Variable_21 * ConstantsCache.Variable_52;

            // Y
            float Variable_23; // Y output 0
            Variable_23 = Context.Y;

            // X
            float Variable_17; // X output 0
            Variable_17 = Context.X;

            // ATAN2
            float Variable_16; // ATAN2 output 0
            Variable_16 = FVoxelNodeFunctions::Atan2(Variable_23, Variable_17);

            // /
            float Variable_19; // / output 0
            Variable_19 = Variable_16 / ConstantsCache.Variable_18;

            // *
            float Variable_22; // * output 0
            Variable_22 = ConstantsCache.Variable_102 * Variable_19;

            // *
            float Variable_51; // * output 0
            Variable_51 = Variable_22 * ConstantsCache.Variable_52;

            // 2D Simplex Noise
            float Variable_58; // 2D Simplex Noise output 0
            Variable_58 = _2D_Simplex_Noise_8750_Noise.GetSimplex(Variable_50, Variable_51);

            // Z
            float Variable_77; // Z output 0
            Variable_77 = Context.Z;

            // /
            float Variable_78; // / output 0
            Variable_78 = Variable_77 / Variable_24;

            // 2D Simplex Noise
            float Variable_85; // 2D Simplex Noise output 0
            Variable_85 = _2D_Simplex_Noise_8749_Noise.GetSimplex(Variable_22, Variable_22);

            // *
            float Variable_82; // * output 0
            Variable_82 = Variable_85 * float(0.1f);

            // +
            float Variable_81; // + output 0
            Variable_81 = Variable_78 + Variable_82;

            // ACOS
            float Variable_79; // ACOS output 0
            Variable_79 = FVoxelNodeFunctions::Acos(Variable_81);

            // /
            float Variable_76; // / output 0
            Variable_76 = Variable_79 / ConstantsCache.Variable_68;

            // 1 - X
            float Variable_74; // 1 - X output 0
            Variable_74 = 1 - Variable_76;

            // Min (float)
            float Variable_73; // Min (float) output 0
            Variable_73 = FVoxelNodeFunctions::Min<float>(Variable_76, Variable_74);

            // /
            float Variable_75; // / output 0
            Variable_75 = Variable_73 / float(0.5f);

            // 1 - X
            float Variable_83; // 1 - X output 0
            Variable_83 = 1 - Variable_75;

            // *
            float Variable_84; // * output 0
            Variable_84 = Variable_83 * float(20.0f);

            // /
            float Variable_103; // / output 0
            Variable_103 = Variable_84 / ConstantsCache.Variable_104;

            // RiverCurve
            float Variable_67; // RiverCurve output 0
            Variable_67 = RiverMask.Eval(Variable_103);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_99; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_99 = FMath::Clamp<float>(Variable_67, -1.000000, 1.000000);

            // Min (float)
            float Variable_86; // Min (float) output 0
            Variable_86 = FVoxelNodeFunctions::Min<float>(Variable_99, float(0.0f));

            // *
            float Variable_87; // * output 0
            Variable_87 = Variable_86 * float(-1.0f);

            // *
            float Variable_88; // * output 0
            Variable_88 = Variable_58 * Variable_87;

            // 1 - X
            float Variable_89; // 1 - X output 0
            Variable_89 = 1 - Variable_87;

            // -
            float Variable_90; // - output 0
            Variable_90 = Variable_88 - Variable_89;

            // BlendColors.Clamp
            float Variable_53; // BlendColors.Clamp output 0
            Variable_53 = FVoxelNodeFunctions::Clamp(Variable_90, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_128; // BlendColors.Lerp output 0
            Variable_128 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_61, ConstantsCache.Variable_54, Variable_53);

            // *
            float Variable_97; // * output 0
            Variable_97 = Variable_99 * float(10.0f);

            // BlendColors.Clamp
            float Variable_80; // BlendColors.Clamp output 0
            Variable_80 = FVoxelNodeFunctions::Clamp(Variable_97, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_136; // BlendColors.Lerp output 0
            Variable_136 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_92, ConstantsCache.Variable_69, Variable_80);

            // +
            float Variable_91; // + output 0
            Variable_91 = Variable_99 + float(0.3f);

            // BlendColors.Clamp
            float Variable_60; // BlendColors.Clamp output 0
            Variable_60 = FVoxelNodeFunctions::Clamp(Variable_91, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_132; // BlendColors.Lerp output 0
            Variable_132 = FVoxelNodeFunctions::Lerp(Variable_128, Variable_136, Variable_60);

            // *
            float Variable_31; // * output 0
            Variable_31 = Variable_21 * ConstantsCache.Variable_33;

            // *
            float Variable_32; // * output 0
            Variable_32 = Variable_22 * ConstantsCache.Variable_33;

            // 2D Perlin Noise
            float Variable_44; // 2D Perlin Noise output 0
            Variable_44 = _2D_Perlin_Noise_7431_Noise.GetPerlin(Variable_31, Variable_32);

            // BlendColors.Clamp
            float Variable_35; // BlendColors.Clamp output 0
            Variable_35 = FVoxelNodeFunctions::Clamp(Variable_44, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_120; // BlendColors.Lerp output 0
            Variable_120 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_40, ConstantsCache.Variable_46, Variable_35);

            // 2D Simplex Noise Fractal
            float Variable_30; // 2D Simplex Noise Fractal output 0
            Variable_30 = _2D_Simplex_Noise_Fractal_15562_Noise.GetSimplexFractal(Variable_31, Variable_32);

            // BlendColors.Clamp
            float Variable_20; // BlendColors.Clamp output 0
            Variable_20 = FVoxelNodeFunctions::Clamp(Variable_30, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_116; // BlendColors.Lerp output 0
            Variable_116 = FVoxelNodeFunctions::Lerp(Variable_120, ConstantsCache.Variable_36, Variable_20);

            // 1 - X
            float Variable_7; // 1 - X output 0
            Variable_7 = 1 - Variable_6;

            // Min (float)
            float Variable_5; // Min (float) output 0
            Variable_5 = FVoxelNodeFunctions::Min<float>(Variable_6, Variable_7);

            // -
            float Variable_11; // - output 0
            Variable_11 = Variable_5 - ConstantsCache.Variable_28;

            // /
            float Variable_27; // / output 0
            Variable_27 = Variable_11 / ConstantsCache.Variable_29;

            // 1 - X
            float Variable_26; // 1 - X output 0
            Variable_26 = 1 - Variable_27;

            // MountainsCurve
            float Variable_34; // MountainsCurve output 0
            Variable_34 = MoutainsMask.Eval(Variable_26);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_98; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_98 = FMath::Clamp<float>(Variable_34, 0.000000, 1.000000);

            // *
            float Variable_59; // * output 0
            Variable_59 = Variable_98 * float(3.0f);

            // Max (float)
            float Variable_65; // Max (float) output 0
            Variable_65 = FVoxelNodeFunctions::Max<float>(Variable_90, float(0.0f));

            // -
            float Variable_66; // - output 0
            Variable_66 = Variable_59 - Variable_65;

            // BlendColors.Clamp
            float Variable_45; // BlendColors.Clamp output 0
            Variable_45 = FVoxelNodeFunctions::Clamp(Variable_66, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_124; // BlendColors.Lerp output 0
            Variable_124 = FVoxelNodeFunctions::Lerp(Variable_132, Variable_116, Variable_45);

            // Max (float)
            float Variable_12; // Max (float) output 0
            Variable_12 = FVoxelNodeFunctions::Max<float>(Variable_27, float(0.0f));

            // *
            float Variable_13; // * output 0
            Variable_13 = Variable_12 * ConstantsCache.Variable_15;

            // Min (float)
            float Variable_14; // Min (float) output 0
            Variable_14 = FVoxelNodeFunctions::Min<float>(Variable_13, float(1.0f));

            // -
            float Variable_111; // - output 0
            Variable_111 = ConstantsCache.Variable_107 - Variable_24;

            // Clamp
            float Variable_105; // Clamp output 0
            Variable_105 = FVoxelNodeFunctions::Clamp(Variable_111, float(0.0f), float(1.0f));

            // Min (float)
            float Variable_106; // Min (float) output 0
            Variable_106 = FVoxelNodeFunctions::Min<float>(Variable_14, Variable_105);

            // BlendColors.Clamp
            float Variable_96; // BlendColors.Clamp output 0
            Variable_96 = FVoxelNodeFunctions::Clamp(Variable_106, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_140; // BlendColors.Lerp output 0
            Variable_140 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_112, Variable_124, Variable_96);

            // BlendColors.Lerp
            float Variable_129; // BlendColors.Lerp output 0
            Variable_129 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_62, ConstantsCache.Variable_55, Variable_53);

            // BlendColors.Lerp
            float Variable_137; // BlendColors.Lerp output 0
            Variable_137 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_93, ConstantsCache.Variable_70, Variable_80);

            // BlendColors.Lerp
            float Variable_133; // BlendColors.Lerp output 0
            Variable_133 = FVoxelNodeFunctions::Lerp(Variable_129, Variable_137, Variable_60);

            // BlendColors.Lerp
            float Variable_121; // BlendColors.Lerp output 0
            Variable_121 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_41, ConstantsCache.Variable_47, Variable_35);

            // BlendColors.Lerp
            float Variable_117; // BlendColors.Lerp output 0
            Variable_117 = FVoxelNodeFunctions::Lerp(Variable_121, ConstantsCache.Variable_37, Variable_20);

            // BlendColors.Lerp
            float Variable_125; // BlendColors.Lerp output 0
            Variable_125 = FVoxelNodeFunctions::Lerp(Variable_133, Variable_117, Variable_45);

            // BlendColors.Lerp
            float Variable_141; // BlendColors.Lerp output 0
            Variable_141 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_113, Variable_125, Variable_96);

            // BlendColors.Lerp
            float Variable_130; // BlendColors.Lerp output 0
            Variable_130 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_63, ConstantsCache.Variable_56, Variable_53);

            // BlendColors.Lerp
            float Variable_138; // BlendColors.Lerp output 0
            Variable_138 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_94, ConstantsCache.Variable_71, Variable_80);

            // BlendColors.Lerp
            float Variable_134; // BlendColors.Lerp output 0
            Variable_134 = FVoxelNodeFunctions::Lerp(Variable_130, Variable_138, Variable_60);

            // BlendColors.Lerp
            float Variable_122; // BlendColors.Lerp output 0
            Variable_122 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_42, ConstantsCache.Variable_48, Variable_35);

            // BlendColors.Lerp
            float Variable_118; // BlendColors.Lerp output 0
            Variable_118 = FVoxelNodeFunctions::Lerp(Variable_122, ConstantsCache.Variable_38, Variable_20);

            // BlendColors.Lerp
            float Variable_126; // BlendColors.Lerp output 0
            Variable_126 = FVoxelNodeFunctions::Lerp(Variable_134, Variable_118, Variable_45);

            // BlendColors.Lerp
            float Variable_142; // BlendColors.Lerp output 0
            Variable_142 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_114, Variable_126, Variable_96);

            // BlendColors.Lerp
            float Variable_131; // BlendColors.Lerp output 0
            Variable_131 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_64, ConstantsCache.Variable_57, Variable_53);

            // BlendColors.Lerp
            float Variable_139; // BlendColors.Lerp output 0
            Variable_139 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_95, ConstantsCache.Variable_72, Variable_80);

            // BlendColors.Lerp
            float Variable_135; // BlendColors.Lerp output 0
            Variable_135 = FVoxelNodeFunctions::Lerp(Variable_131, Variable_139, Variable_60);

            // BlendColors.Lerp
            float Variable_123; // BlendColors.Lerp output 0
            Variable_123 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_43, ConstantsCache.Variable_49, Variable_35);

            // BlendColors.Lerp
            float Variable_119; // BlendColors.Lerp output 0
            Variable_119 = FVoxelNodeFunctions::Lerp(Variable_123, ConstantsCache.Variable_39, Variable_20);

            // BlendColors.Lerp
            float Variable_127; // BlendColors.Lerp output 0
            Variable_127 = FVoxelNodeFunctions::Lerp(Variable_135, Variable_119, Variable_45);

            // BlendColors.Lerp
            float Variable_143; // BlendColors.Lerp output 0
            Variable_143 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_115, Variable_127, Variable_96);

            GraphOutputs.Material.SetColor(FLinearColor(Variable_140, Variable_141, Variable_142, Variable_143));
        }

    };
    struct FLocalComputeStruct_LocalValueMaterial_LOD0
    {
        struct FVoxelGraphOutputs
        {
            float& Value;
            FVoxelMaterial& Material;
        };
        struct FVoxelConstantsCache
        {
            float Variable_76; // PlainsNoiseFrequency = 0.2 output 0
            float Variable_5; // Radius = 7000.0 output 0
            float Variable_22; // RingEdgesHardness = 10.0 output 0
            float Variable_25; // PI.3.141593 output 0
            float Variable_32; // Width in Degrees = 50.0 output 0
            float Variable_86; // PlainsColorLow output 0
            float Variable_87; // PlainsColorLow output 1
            float Variable_88; // PlainsColorLow output 2
            float Variable_89; // PlainsColorLow output 3
            float Variable_94; // RiverDepth = 100.0 output 0
            float Variable_41; // BaseHeight = 1000.0 output 0
            float Variable_44; // BaseNoiseHeight = 250.0 output 0
            float Variable_47; // BaseNoiseFrquency = 0.005 output 0
            float Variable_50; // MountainsNoiseHeight = 500.0 output 0
            float Variable_53; // MountainsNoiseFrequency = 0.2 output 0
            float Variable_56; // MountainsColorHigh output 0
            float Variable_57; // MountainsColorHigh output 1
            float Variable_58; // MountainsColorHigh output 2
            float Variable_59; // MountainsColorHigh output 3
            float Variable_60; // MountainsColorLowLow output 0
            float Variable_61; // MountainsColorLowLow output 1
            float Variable_62; // MountainsColorLowLow output 2
            float Variable_63; // MountainsColorLowLow output 3
            float Variable_67; // MountainsColorLowHigh output 0
            float Variable_68; // MountainsColorLowHigh output 1
            float Variable_69; // MountainsColorLowHigh output 2
            float Variable_70; // MountainsColorLowHigh output 3
            float Variable_73; // PlainsNoiseHeight = 250.0 output 0
            float Variable_96; // RiverColor output 0
            float Variable_97; // RiverColor output 1
            float Variable_98; // RiverColor output 2
            float Variable_99; // RiverColor output 3
            float Variable_79; // PlainsColorHigh output 0
            float Variable_80; // PlainsColorHigh output 1
            float Variable_81; // PlainsColorHigh output 2
            float Variable_82; // PlainsColorHigh output 3
            float Variable_143; // RingOuterColor output 0
            float Variable_144; // RingOuterColor output 1
            float Variable_145; // RingOuterColor output 2
            float Variable_146; // RingOuterColor output 3
            float Variable_95; // PI.3.141593 output 0
            float Variable_135; // RiverWidth = 1.0 output 0
            float Variable_120; // BeachColor output 0
            float Variable_121; // BeachColor output 1
            float Variable_122; // BeachColor output 2
            float Variable_123; // BeachColor output 3
            float Variable_130; // Scale = 10.0 output 0
            float Variable_141; // PI.3.141593 output 0
            float Variable_139; // Thickness = 500.0 output 0
            float Variable_38; // / output 0
            float Variable_131; // * output 0
            float Variable_140; // * output 0
            float Variable_132; // / output 0
            float Variable_6; // + output 0
            float Variable_37; // - output 0
            float Variable_138; // + output 0
        };
        struct FVoxelCache
        {
            float Variable_0; // X output 0
            float Variable_24; // X output 0
            float Variable_1; // Y output 0
            float Variable_30; // Y output 0
            float Variable_23; // ATAN2 output 0
            float Variable_26; // / output 0
            float Variable_29; // * output 0
            float Variable_46; // * output 0
            float Variable_52; // * output 0
            float Variable_75; // * output 0
            float Variable_112; // 2D Simplex Noise output 0
            float Variable_109; // * output 0
        };

        FLocalComputeStruct_LocalValueMaterial_LOD0(const float& InScale, const float& InPlainsNoiseHeight, const float& InRingEdgesHardness, const float& InWidth_in_Degrees, const float& InRiverDepth, const float& InThickness, const float& InBaseHeight, const float& InBaseNoiseHeight, const float& InBaseNoiseFrquency, const float& InMountainsNoiseHeight, const float& InRadius, const float& InRiverWidth, const float& InPlainsNoiseFrequency, const float& InMountainsNoiseFrequency, const FRichCurve& InRingShape, const FRichCurve& InMoutainsMask, const FRichCurve& InRiverMask, const FRichCurve& InPlainsNoiseStrength, const FLinearColor& InPlainsColorLow, const FLinearColor& InRiverColor, const FLinearColor& InBeachColor, const FLinearColor& InMountainsColorHigh, const FLinearColor& InMountainsColorLowLow, const FLinearColor& InMountainsColorLowHigh, const FLinearColor& InPlainsColorHigh, const FLinearColor& InRingOuterColor)
            : Scale(InScale)
            , PlainsNoiseHeight(InPlainsNoiseHeight)
            , RingEdgesHardness(InRingEdgesHardness)
            , Width_in_Degrees(InWidth_in_Degrees)
            , RiverDepth(InRiverDepth)
            , Thickness(InThickness)
            , BaseHeight(InBaseHeight)
            , BaseNoiseHeight(InBaseNoiseHeight)
            , BaseNoiseFrquency(InBaseNoiseFrquency)
            , MountainsNoiseHeight(InMountainsNoiseHeight)
            , Radius(InRadius)
            , RiverWidth(InRiverWidth)
            , PlainsNoiseFrequency(InPlainsNoiseFrequency)
            , MountainsNoiseFrequency(InMountainsNoiseFrequency)
            , RingShape(InRingShape)
            , MoutainsMask(InMoutainsMask)
            , RiverMask(InRiverMask)
            , PlainsNoiseStrength(InPlainsNoiseStrength)
            , PlainsColorLow(InPlainsColorLow)
            , RiverColor(InRiverColor)
            , BeachColor(InBeachColor)
            , MountainsColorHigh(InMountainsColorHigh)
            , MountainsColorLowLow(InMountainsColorLowLow)
            , MountainsColorLowHigh(InMountainsColorLowHigh)
            , PlainsColorHigh(InPlainsColorHigh)
            , RingOuterColor(InRingOuterColor)
        {
        }

        void Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            FVoxelCache Cache;

            {
            }

            Function0_Init(InitStruct);

            {
                // PlainsNoiseFrequency = 0.2
                ConstantsCache.Variable_76 = PlainsNoiseFrequency;

                // Radius = 7000.0
                ConstantsCache.Variable_5 = Radius;

                // RingEdgesHardness = 10.0
                ConstantsCache.Variable_22 = RingEdgesHardness;

                // PI.3.141593
                ConstantsCache.Variable_25 = 3.141593;

                // Width in Degrees = 50.0
                ConstantsCache.Variable_32 = Width_in_Degrees;

                // PlainsColorLow
                ConstantsCache.Variable_86 = PlainsColorLow.R;
                ConstantsCache.Variable_87 = PlainsColorLow.G;
                ConstantsCache.Variable_88 = PlainsColorLow.B;
                ConstantsCache.Variable_89 = PlainsColorLow.A;

                // RiverDepth = 100.0
                ConstantsCache.Variable_94 = RiverDepth;

                // BaseHeight = 1000.0
                ConstantsCache.Variable_41 = BaseHeight;

                // BaseNoiseHeight = 250.0
                ConstantsCache.Variable_44 = BaseNoiseHeight;

                // BaseNoiseFrquency = 0.005
                ConstantsCache.Variable_47 = BaseNoiseFrquency;

                // MountainsNoiseHeight = 500.0
                ConstantsCache.Variable_50 = MountainsNoiseHeight;

                // MountainsNoiseFrequency = 0.2
                ConstantsCache.Variable_53 = MountainsNoiseFrequency;

                // MountainsColorHigh
                ConstantsCache.Variable_56 = MountainsColorHigh.R;
                ConstantsCache.Variable_57 = MountainsColorHigh.G;
                ConstantsCache.Variable_58 = MountainsColorHigh.B;
                ConstantsCache.Variable_59 = MountainsColorHigh.A;

                // MountainsColorLowLow
                ConstantsCache.Variable_60 = MountainsColorLowLow.R;
                ConstantsCache.Variable_61 = MountainsColorLowLow.G;
                ConstantsCache.Variable_62 = MountainsColorLowLow.B;
                ConstantsCache.Variable_63 = MountainsColorLowLow.A;

                // MountainsColorLowHigh
                ConstantsCache.Variable_67 = MountainsColorLowHigh.R;
                ConstantsCache.Variable_68 = MountainsColorLowHigh.G;
                ConstantsCache.Variable_69 = MountainsColorLowHigh.B;
                ConstantsCache.Variable_70 = MountainsColorLowHigh.A;

                // PlainsNoiseHeight = 250.0
                ConstantsCache.Variable_73 = PlainsNoiseHeight;

                // RiverColor
                ConstantsCache.Variable_96 = RiverColor.R;
                ConstantsCache.Variable_97 = RiverColor.G;
                ConstantsCache.Variable_98 = RiverColor.B;
                ConstantsCache.Variable_99 = RiverColor.A;

                // PlainsColorHigh
                ConstantsCache.Variable_79 = PlainsColorHigh.R;
                ConstantsCache.Variable_80 = PlainsColorHigh.G;
                ConstantsCache.Variable_81 = PlainsColorHigh.B;
                ConstantsCache.Variable_82 = PlainsColorHigh.A;

                // RingOuterColor
                ConstantsCache.Variable_143 = RingOuterColor.R;
                ConstantsCache.Variable_144 = RingOuterColor.G;
                ConstantsCache.Variable_145 = RingOuterColor.B;
                ConstantsCache.Variable_146 = RingOuterColor.A;

                // PI.3.141593
                ConstantsCache.Variable_95 = 3.141593;

                // RiverWidth = 1.0
                ConstantsCache.Variable_135 = RiverWidth;

                // BeachColor
                ConstantsCache.Variable_120 = BeachColor.R;
                ConstantsCache.Variable_121 = BeachColor.G;
                ConstantsCache.Variable_122 = BeachColor.B;
                ConstantsCache.Variable_123 = BeachColor.A;

                // Scale = 10.0
                ConstantsCache.Variable_130 = Scale;

                // PI.3.141593
                ConstantsCache.Variable_141 = 3.141593;

                // Thickness = 500.0
                ConstantsCache.Variable_139 = Thickness;

                // /
                ConstantsCache.Variable_38 = ConstantsCache.Variable_32 / float(360.0f);

                // *
                ConstantsCache.Variable_131 = ConstantsCache.Variable_5 * ConstantsCache.Variable_130;

                // *
                ConstantsCache.Variable_140 = ConstantsCache.Variable_139 * ConstantsCache.Variable_130;

                // /
                ConstantsCache.Variable_132 = ConstantsCache.Variable_131 / ConstantsCache.Variable_130;

                // +
                ConstantsCache.Variable_6 = ConstantsCache.Variable_131 + ConstantsCache.Variable_140;

                // -
                ConstantsCache.Variable_37 = float(0.5f) - ConstantsCache.Variable_38;

                // +
                ConstantsCache.Variable_138 = ConstantsCache.Variable_131 + ConstantsCache.Variable_140 + float(-5.0f);

            }
        }
        void ComputeX(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_X_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXY(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XY_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXYZ(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XYZ_Compute(GraphOutputs, Cache, Context);
        }
        void Get(const FVoxelContext&Context, float& Value, FVoxelMaterial& Material) const
        {
            FVoxelGraphOutputs GraphOutputs{Value, Material};
            Function0_Compute(GraphOutputs, Context);
        }

    private:
        FVoxelConstantsCache ConstantsCache;
        FastNoise _2D_Simplex_Noise_8751_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15563_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15564_Noise;
        FastNoise _2D_Perlin_Noise_7432_Noise;
        FastNoise _2D_Simplex_Noise_8752_Noise;

        const float& Scale;
        const float& PlainsNoiseHeight;
        const float& RingEdgesHardness;
        const float& Width_in_Degrees;
        const float& RiverDepth;
        const float& Thickness;
        const float& BaseHeight;
        const float& BaseNoiseHeight;
        const float& BaseNoiseFrquency;
        const float& MountainsNoiseHeight;
        const float& Radius;
        const float& RiverWidth;
        const float& PlainsNoiseFrequency;
        const float& MountainsNoiseFrequency;
        const FRichCurve& RingShape;
        const FRichCurve& MoutainsMask;
        const FRichCurve& RiverMask;
        const FRichCurve& PlainsNoiseStrength;
        const FLinearColor& PlainsColorLow;
        const FLinearColor& RiverColor;
        const FLinearColor& BeachColor;
        const FLinearColor& MountainsColorHigh;
        const FLinearColor& MountainsColorLowLow;
        const FLinearColor& MountainsColorLowHigh;
        const FLinearColor& PlainsColorHigh;
        const FLinearColor& RingOuterColor;

        ///////////////////////////////////////////////////////////////////////
        //////////////////////////// Init functions ///////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15563_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15563_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15563_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15563_Noise.SetFractalOctaves(5);
            _2D_Simplex_Noise_Fractal_15563_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15563_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15563_Noise.SetFractalType(FastNoise::FractalType::FBM);

            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15564_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15564_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15564_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15564_Noise.SetFractalOctaves(8);
            _2D_Simplex_Noise_Fractal_15564_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15564_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15564_Noise.SetFractalType(FastNoise::FractalType::FBM);

            // Init of 2D Perlin Noise
            _2D_Perlin_Noise_7432_Noise.SetSeed(Seed(1338));
            _2D_Perlin_Noise_7432_Noise.SetFrequency(0.1);
            _2D_Perlin_Noise_7432_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8752_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_8752_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_8752_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8751_Noise.SetSeed(Seed(1000));
            _2D_Simplex_Noise_8751_Noise.SetFrequency(0.001);
            _2D_Simplex_Noise_8751_Noise.SetInterp(FastNoise::Interp::Quintic);

        }

        ///////////////////////////////////////////////////////////////////////
        ////////////////////////// Compute functions //////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_X_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // X
            Cache.Variable_0 = Context.X;

            // X
            Cache.Variable_24 = Context.X;

        }

        void Function0_XY_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // Y
            Cache.Variable_1 = Context.Y;

            // Y
            Cache.Variable_30 = Context.Y;

            // ATAN2
            Cache.Variable_23 = FVoxelNodeFunctions::Atan2(Cache.Variable_30, Cache.Variable_24);

            // /
            Cache.Variable_26 = Cache.Variable_23 / ConstantsCache.Variable_25;

            // *
            Cache.Variable_29 = ConstantsCache.Variable_132 * Cache.Variable_26;

            // *
            Cache.Variable_46 = Cache.Variable_29 * ConstantsCache.Variable_47;

            // *
            Cache.Variable_52 = Cache.Variable_29 * ConstantsCache.Variable_53;

            // *
            Cache.Variable_75 = Cache.Variable_29 * ConstantsCache.Variable_76;

            // 2D Simplex Noise
            Cache.Variable_112 = _2D_Simplex_Noise_8751_Noise.GetSimplex(Cache.Variable_29, Cache.Variable_29);

            // *
            Cache.Variable_109 = Cache.Variable_112 * float(0.1f);

        }

        void Function0_XYZ_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // Z
            float Variable_12; // Z output 0
            Variable_12 = Context.Z;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Cache.Variable_0, Cache.Variable_1, Variable_2);

            // +
            float Variable_31; // + output 0
            Variable_31 = Variable_3 + float(0.001f);

            // /
            float Variable_13; // / output 0
            Variable_13 = Variable_12 / Variable_31;

            // ACOS
            float Variable_14; // ACOS output 0
            Variable_14 = FVoxelNodeFunctions::Acos(Variable_13);

            // /
            float Variable_10; // / output 0
            Variable_10 = Variable_14 / ConstantsCache.Variable_141;

            // 1 - X
            float Variable_11; // 1 - X output 0
            Variable_11 = 1 - Variable_10;

            // Min (float)
            float Variable_9; // Min (float) output 0
            Variable_9 = FVoxelNodeFunctions::Min<float>(Variable_10, Variable_11);

            // -
            float Variable_15; // - output 0
            Variable_15 = Variable_9 - ConstantsCache.Variable_37;

            // /
            float Variable_36; // / output 0
            Variable_36 = Variable_15 / ConstantsCache.Variable_38;

            // 1 - X
            float Variable_35; // 1 - X output 0
            Variable_35 = 1 - Variable_36;

            // RingCurve
            float Variable_39; // RingCurve output 0
            Variable_39 = RingShape.Eval(Variable_35);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_126; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_126 = FMath::Clamp<float>(Variable_39, 0.000000, 1.000000);

            // *
            float Variable_40; // * output 0
            Variable_40 = Variable_126 * ConstantsCache.Variable_41;

            // *
            float Variable_28; // * output 0
            Variable_28 = ConstantsCache.Variable_132 * Variable_10;

            // *
            float Variable_45; // * output 0
            Variable_45 = Variable_28 * ConstantsCache.Variable_47;

            // 2D Simplex Noise Fractal
            float Variable_42; // 2D Simplex Noise Fractal output 0
            Variable_42 = _2D_Simplex_Noise_Fractal_15563_Noise.GetSimplexFractal(Variable_45, Cache.Variable_46);

            // *
            float Variable_43; // * output 0
            Variable_43 = Variable_42 * ConstantsCache.Variable_44;

            // *
            float Variable_51; // * output 0
            Variable_51 = Variable_28 * ConstantsCache.Variable_53;

            // 2D Simplex Noise Fractal
            float Variable_48; // 2D Simplex Noise Fractal output 0
            Variable_48 = _2D_Simplex_Noise_Fractal_15564_Noise.GetSimplexFractal(Variable_51, Cache.Variable_52);

            // MountainsCurve
            float Variable_54; // MountainsCurve output 0
            Variable_54 = MoutainsMask.Eval(Variable_35);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_127; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_127 = FMath::Clamp<float>(Variable_54, 0.000000, 1.000000);

            // *
            float Variable_49; // * output 0
            Variable_49 = Variable_48 * ConstantsCache.Variable_50 * Variable_127;

            // 2D Perlin Noise
            float Variable_64; // 2D Perlin Noise output 0
            Variable_64 = _2D_Perlin_Noise_7432_Noise.GetPerlin(Variable_51, Cache.Variable_52);

            // *
            float Variable_65; // * output 0
            Variable_65 = ConstantsCache.Variable_50 * Variable_127 * Variable_64 * float(0.1f);

            // *
            float Variable_74; // * output 0
            Variable_74 = Variable_28 * ConstantsCache.Variable_76;

            // 2D Simplex Noise
            float Variable_83; // 2D Simplex Noise output 0
            Variable_83 = _2D_Simplex_Noise_8752_Noise.GetSimplex(Variable_74, Cache.Variable_75);

            // Z
            float Variable_104; // Z output 0
            Variable_104 = Context.Z;

            // /
            float Variable_105; // / output 0
            Variable_105 = Variable_104 / Variable_31;

            // +
            float Variable_108; // + output 0
            Variable_108 = Variable_105 + Cache.Variable_109;

            // ACOS
            float Variable_106; // ACOS output 0
            Variable_106 = FVoxelNodeFunctions::Acos(Variable_108);

            // /
            float Variable_103; // / output 0
            Variable_103 = Variable_106 / ConstantsCache.Variable_95;

            // 1 - X
            float Variable_101; // 1 - X output 0
            Variable_101 = 1 - Variable_103;

            // Min (float)
            float Variable_100; // Min (float) output 0
            Variable_100 = FVoxelNodeFunctions::Min<float>(Variable_103, Variable_101);

            // /
            float Variable_102; // / output 0
            Variable_102 = Variable_100 / float(0.5f);

            // 1 - X
            float Variable_110; // 1 - X output 0
            Variable_110 = 1 - Variable_102;

            // *
            float Variable_111; // * output 0
            Variable_111 = Variable_110 * float(20.0f);

            // /
            float Variable_134; // / output 0
            Variable_134 = Variable_111 / ConstantsCache.Variable_135;

            // RiverCurve
            float Variable_92; // RiverCurve output 0
            Variable_92 = RiverMask.Eval(Variable_134);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_129; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_129 = FMath::Clamp<float>(Variable_92, -1.000000, 1.000000);

            // Min (float)
            float Variable_114; // Min (float) output 0
            Variable_114 = FVoxelNodeFunctions::Min<float>(Variable_129, float(0.0f));

            // *
            float Variable_115; // * output 0
            Variable_115 = Variable_114 * float(-1.0f);

            // *
            float Variable_116; // * output 0
            Variable_116 = Variable_83 * Variable_115;

            // 1 - X
            float Variable_117; // 1 - X output 0
            Variable_117 = 1 - Variable_115;

            // -
            float Variable_118; // - output 0
            Variable_118 = Variable_116 - Variable_117;

            // 1 - X
            float Variable_71; // 1 - X output 0
            Variable_71 = 1 - Variable_127;

            // PlainsNoiseStrengthCurve
            float Variable_77; // PlainsNoiseStrengthCurve output 0
            Variable_77 = PlainsNoiseStrength.Eval(Variable_35);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_128; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_128 = FMath::Clamp<float>(Variable_77, 0.000000, 1.000000);

            // *
            float Variable_72; // * output 0
            Variable_72 = Variable_118 * ConstantsCache.Variable_73 * Variable_71 * Variable_128;

            // Max (float)
            float Variable_113; // Max (float) output 0
            Variable_113 = FVoxelNodeFunctions::Max<float>(Variable_129, float(0.0f));

            // *
            float Variable_93; // * output 0
            Variable_93 = Variable_113 * float(-1.0f) * ConstantsCache.Variable_94;

            // +
            float Variable_34; // + output 0
            Variable_34 = Variable_40 + Variable_43 + Variable_49 + Variable_65 + Variable_72 + Variable_93;

            // *
            float Variable_133; // * output 0
            Variable_133 = Variable_34 * ConstantsCache.Variable_130;

            // -
            float Variable_33; // - output 0
            Variable_33 = ConstantsCache.Variable_131 - Variable_133;

            // -
            float Variable_4; // - output 0
            Variable_4 = Variable_33 - Variable_31;

            // -
            float Variable_7; // - output 0
            Variable_7 = Variable_31 - ConstantsCache.Variable_6;

            // Max (float)
            float Variable_8; // Max (float) output 0
            Variable_8 = FVoxelNodeFunctions::Max<float>(Variable_4, Variable_7);

            // -
            float Variable_19; // - output 0
            Variable_19 = Variable_8 - float(1.0f);

            // Max (float)
            float Variable_18; // Max (float) output 0
            Variable_18 = FVoxelNodeFunctions::Max<float>(Variable_36, float(0.0f));

            // *
            float Variable_20; // * output 0
            Variable_20 = Variable_18 * ConstantsCache.Variable_22;

            // Min (float)
            float Variable_21; // Min (float) output 0
            Variable_21 = FVoxelNodeFunctions::Min<float>(Variable_20, float(1.0f));

            // *
            float Variable_16; // * output 0
            Variable_16 = Variable_19 * Variable_21;

            // +
            float Variable_17; // + output 0
            Variable_17 = Variable_16 + float(1.0f);

            GraphOutputs.Value = Variable_17;
            // BlendColors.Clamp
            float Variable_78; // BlendColors.Clamp output 0
            Variable_78 = FVoxelNodeFunctions::Clamp(Variable_118, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_159; // BlendColors.Lerp output 0
            Variable_159 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_86, ConstantsCache.Variable_79, Variable_78);

            // *
            float Variable_125; // * output 0
            Variable_125 = Variable_129 * float(10.0f);

            // BlendColors.Clamp
            float Variable_107; // BlendColors.Clamp output 0
            Variable_107 = FVoxelNodeFunctions::Clamp(Variable_125, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_167; // BlendColors.Lerp output 0
            Variable_167 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_120, ConstantsCache.Variable_96, Variable_107);

            // +
            float Variable_119; // + output 0
            Variable_119 = Variable_129 + float(0.3f);

            // BlendColors.Clamp
            float Variable_85; // BlendColors.Clamp output 0
            Variable_85 = FVoxelNodeFunctions::Clamp(Variable_119, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_163; // BlendColors.Lerp output 0
            Variable_163 = FVoxelNodeFunctions::Lerp(Variable_159, Variable_167, Variable_85);

            // BlendColors.Clamp
            float Variable_55; // BlendColors.Clamp output 0
            Variable_55 = FVoxelNodeFunctions::Clamp(Variable_64, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_151; // BlendColors.Lerp output 0
            Variable_151 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_60, ConstantsCache.Variable_67, Variable_55);

            // BlendColors.Clamp
            float Variable_27; // BlendColors.Clamp output 0
            Variable_27 = FVoxelNodeFunctions::Clamp(Variable_48, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_147; // BlendColors.Lerp output 0
            Variable_147 = FVoxelNodeFunctions::Lerp(Variable_151, ConstantsCache.Variable_56, Variable_27);

            // *
            float Variable_84; // * output 0
            Variable_84 = Variable_127 * float(3.0f);

            // Max (float)
            float Variable_90; // Max (float) output 0
            Variable_90 = FVoxelNodeFunctions::Max<float>(Variable_118, float(0.0f));

            // -
            float Variable_91; // - output 0
            Variable_91 = Variable_84 - Variable_90;

            // BlendColors.Clamp
            float Variable_66; // BlendColors.Clamp output 0
            Variable_66 = FVoxelNodeFunctions::Clamp(Variable_91, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_155; // BlendColors.Lerp output 0
            Variable_155 = FVoxelNodeFunctions::Lerp(Variable_163, Variable_147, Variable_66);

            // -
            float Variable_142; // - output 0
            Variable_142 = ConstantsCache.Variable_138 - Variable_31;

            // Clamp
            float Variable_136; // Clamp output 0
            Variable_136 = FVoxelNodeFunctions::Clamp(Variable_142, float(0.0f), float(1.0f));

            // Min (float)
            float Variable_137; // Min (float) output 0
            Variable_137 = FVoxelNodeFunctions::Min<float>(Variable_21, Variable_136);

            // BlendColors.Clamp
            float Variable_124; // BlendColors.Clamp output 0
            Variable_124 = FVoxelNodeFunctions::Clamp(Variable_137, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_171; // BlendColors.Lerp output 0
            Variable_171 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_143, Variable_155, Variable_124);

            // BlendColors.Lerp
            float Variable_160; // BlendColors.Lerp output 0
            Variable_160 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_87, ConstantsCache.Variable_80, Variable_78);

            // BlendColors.Lerp
            float Variable_168; // BlendColors.Lerp output 0
            Variable_168 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_121, ConstantsCache.Variable_97, Variable_107);

            // BlendColors.Lerp
            float Variable_164; // BlendColors.Lerp output 0
            Variable_164 = FVoxelNodeFunctions::Lerp(Variable_160, Variable_168, Variable_85);

            // BlendColors.Lerp
            float Variable_152; // BlendColors.Lerp output 0
            Variable_152 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_61, ConstantsCache.Variable_68, Variable_55);

            // BlendColors.Lerp
            float Variable_148; // BlendColors.Lerp output 0
            Variable_148 = FVoxelNodeFunctions::Lerp(Variable_152, ConstantsCache.Variable_57, Variable_27);

            // BlendColors.Lerp
            float Variable_156; // BlendColors.Lerp output 0
            Variable_156 = FVoxelNodeFunctions::Lerp(Variable_164, Variable_148, Variable_66);

            // BlendColors.Lerp
            float Variable_172; // BlendColors.Lerp output 0
            Variable_172 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_144, Variable_156, Variable_124);

            // BlendColors.Lerp
            float Variable_161; // BlendColors.Lerp output 0
            Variable_161 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_88, ConstantsCache.Variable_81, Variable_78);

            // BlendColors.Lerp
            float Variable_169; // BlendColors.Lerp output 0
            Variable_169 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_122, ConstantsCache.Variable_98, Variable_107);

            // BlendColors.Lerp
            float Variable_165; // BlendColors.Lerp output 0
            Variable_165 = FVoxelNodeFunctions::Lerp(Variable_161, Variable_169, Variable_85);

            // BlendColors.Lerp
            float Variable_153; // BlendColors.Lerp output 0
            Variable_153 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_62, ConstantsCache.Variable_69, Variable_55);

            // BlendColors.Lerp
            float Variable_149; // BlendColors.Lerp output 0
            Variable_149 = FVoxelNodeFunctions::Lerp(Variable_153, ConstantsCache.Variable_58, Variable_27);

            // BlendColors.Lerp
            float Variable_157; // BlendColors.Lerp output 0
            Variable_157 = FVoxelNodeFunctions::Lerp(Variable_165, Variable_149, Variable_66);

            // BlendColors.Lerp
            float Variable_173; // BlendColors.Lerp output 0
            Variable_173 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_145, Variable_157, Variable_124);

            // BlendColors.Lerp
            float Variable_162; // BlendColors.Lerp output 0
            Variable_162 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_89, ConstantsCache.Variable_82, Variable_78);

            // BlendColors.Lerp
            float Variable_170; // BlendColors.Lerp output 0
            Variable_170 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_123, ConstantsCache.Variable_99, Variable_107);

            // BlendColors.Lerp
            float Variable_166; // BlendColors.Lerp output 0
            Variable_166 = FVoxelNodeFunctions::Lerp(Variable_162, Variable_170, Variable_85);

            // BlendColors.Lerp
            float Variable_154; // BlendColors.Lerp output 0
            Variable_154 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_63, ConstantsCache.Variable_70, Variable_55);

            // BlendColors.Lerp
            float Variable_150; // BlendColors.Lerp output 0
            Variable_150 = FVoxelNodeFunctions::Lerp(Variable_154, ConstantsCache.Variable_59, Variable_27);

            // BlendColors.Lerp
            float Variable_158; // BlendColors.Lerp output 0
            Variable_158 = FVoxelNodeFunctions::Lerp(Variable_166, Variable_150, Variable_66);

            // BlendColors.Lerp
            float Variable_174; // BlendColors.Lerp output 0
            Variable_174 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_146, Variable_158, Variable_124);

            GraphOutputs.Material.SetColor(FLinearColor(Variable_171, Variable_172, Variable_173, Variable_174));
        }

        void Function0_Compute(FVoxelGraphOutputs& GraphOutputs, const FVoxelContext& Context) const
        {
            // Z
            float Variable_12; // Z output 0
            Variable_12 = Context.Z;

            // X
            float Variable_0; // X output 0
            Variable_0 = Context.X;

            // Y
            float Variable_1; // Y output 0
            Variable_1 = Context.Y;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Variable_0, Variable_1, Variable_2);

            // +
            float Variable_31; // + output 0
            Variable_31 = Variable_3 + float(0.001f);

            // /
            float Variable_13; // / output 0
            Variable_13 = Variable_12 / Variable_31;

            // ACOS
            float Variable_14; // ACOS output 0
            Variable_14 = FVoxelNodeFunctions::Acos(Variable_13);

            // /
            float Variable_10; // / output 0
            Variable_10 = Variable_14 / ConstantsCache.Variable_141;

            // 1 - X
            float Variable_11; // 1 - X output 0
            Variable_11 = 1 - Variable_10;

            // Min (float)
            float Variable_9; // Min (float) output 0
            Variable_9 = FVoxelNodeFunctions::Min<float>(Variable_10, Variable_11);

            // -
            float Variable_15; // - output 0
            Variable_15 = Variable_9 - ConstantsCache.Variable_37;

            // /
            float Variable_36; // / output 0
            Variable_36 = Variable_15 / ConstantsCache.Variable_38;

            // 1 - X
            float Variable_35; // 1 - X output 0
            Variable_35 = 1 - Variable_36;

            // RingCurve
            float Variable_39; // RingCurve output 0
            Variable_39 = RingShape.Eval(Variable_35);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_126; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_126 = FMath::Clamp<float>(Variable_39, 0.000000, 1.000000);

            // *
            float Variable_40; // * output 0
            Variable_40 = Variable_126 * ConstantsCache.Variable_41;

            // *
            float Variable_28; // * output 0
            Variable_28 = ConstantsCache.Variable_132 * Variable_10;

            // *
            float Variable_45; // * output 0
            Variable_45 = Variable_28 * ConstantsCache.Variable_47;

            // Y
            float Variable_30; // Y output 0
            Variable_30 = Context.Y;

            // X
            float Variable_24; // X output 0
            Variable_24 = Context.X;

            // ATAN2
            float Variable_23; // ATAN2 output 0
            Variable_23 = FVoxelNodeFunctions::Atan2(Variable_30, Variable_24);

            // /
            float Variable_26; // / output 0
            Variable_26 = Variable_23 / ConstantsCache.Variable_25;

            // *
            float Variable_29; // * output 0
            Variable_29 = ConstantsCache.Variable_132 * Variable_26;

            // *
            float Variable_46; // * output 0
            Variable_46 = Variable_29 * ConstantsCache.Variable_47;

            // 2D Simplex Noise Fractal
            float Variable_42; // 2D Simplex Noise Fractal output 0
            Variable_42 = _2D_Simplex_Noise_Fractal_15563_Noise.GetSimplexFractal(Variable_45, Variable_46);

            // *
            float Variable_43; // * output 0
            Variable_43 = Variable_42 * ConstantsCache.Variable_44;

            // *
            float Variable_51; // * output 0
            Variable_51 = Variable_28 * ConstantsCache.Variable_53;

            // *
            float Variable_52; // * output 0
            Variable_52 = Variable_29 * ConstantsCache.Variable_53;

            // 2D Simplex Noise Fractal
            float Variable_48; // 2D Simplex Noise Fractal output 0
            Variable_48 = _2D_Simplex_Noise_Fractal_15564_Noise.GetSimplexFractal(Variable_51, Variable_52);

            // MountainsCurve
            float Variable_54; // MountainsCurve output 0
            Variable_54 = MoutainsMask.Eval(Variable_35);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_127; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_127 = FMath::Clamp<float>(Variable_54, 0.000000, 1.000000);

            // *
            float Variable_49; // * output 0
            Variable_49 = Variable_48 * ConstantsCache.Variable_50 * Variable_127;

            // 2D Perlin Noise
            float Variable_64; // 2D Perlin Noise output 0
            Variable_64 = _2D_Perlin_Noise_7432_Noise.GetPerlin(Variable_51, Variable_52);

            // *
            float Variable_65; // * output 0
            Variable_65 = ConstantsCache.Variable_50 * Variable_127 * Variable_64 * float(0.1f);

            // *
            float Variable_74; // * output 0
            Variable_74 = Variable_28 * ConstantsCache.Variable_76;

            // *
            float Variable_75; // * output 0
            Variable_75 = Variable_29 * ConstantsCache.Variable_76;

            // 2D Simplex Noise
            float Variable_83; // 2D Simplex Noise output 0
            Variable_83 = _2D_Simplex_Noise_8752_Noise.GetSimplex(Variable_74, Variable_75);

            // Z
            float Variable_104; // Z output 0
            Variable_104 = Context.Z;

            // /
            float Variable_105; // / output 0
            Variable_105 = Variable_104 / Variable_31;

            // 2D Simplex Noise
            float Variable_112; // 2D Simplex Noise output 0
            Variable_112 = _2D_Simplex_Noise_8751_Noise.GetSimplex(Variable_29, Variable_29);

            // *
            float Variable_109; // * output 0
            Variable_109 = Variable_112 * float(0.1f);

            // +
            float Variable_108; // + output 0
            Variable_108 = Variable_105 + Variable_109;

            // ACOS
            float Variable_106; // ACOS output 0
            Variable_106 = FVoxelNodeFunctions::Acos(Variable_108);

            // /
            float Variable_103; // / output 0
            Variable_103 = Variable_106 / ConstantsCache.Variable_95;

            // 1 - X
            float Variable_101; // 1 - X output 0
            Variable_101 = 1 - Variable_103;

            // Min (float)
            float Variable_100; // Min (float) output 0
            Variable_100 = FVoxelNodeFunctions::Min<float>(Variable_103, Variable_101);

            // /
            float Variable_102; // / output 0
            Variable_102 = Variable_100 / float(0.5f);

            // 1 - X
            float Variable_110; // 1 - X output 0
            Variable_110 = 1 - Variable_102;

            // *
            float Variable_111; // * output 0
            Variable_111 = Variable_110 * float(20.0f);

            // /
            float Variable_134; // / output 0
            Variable_134 = Variable_111 / ConstantsCache.Variable_135;

            // RiverCurve
            float Variable_92; // RiverCurve output 0
            Variable_92 = RiverMask.Eval(Variable_134);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_129; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_129 = FMath::Clamp<float>(Variable_92, -1.000000, 1.000000);

            // Min (float)
            float Variable_114; // Min (float) output 0
            Variable_114 = FVoxelNodeFunctions::Min<float>(Variable_129, float(0.0f));

            // *
            float Variable_115; // * output 0
            Variable_115 = Variable_114 * float(-1.0f);

            // *
            float Variable_116; // * output 0
            Variable_116 = Variable_83 * Variable_115;

            // 1 - X
            float Variable_117; // 1 - X output 0
            Variable_117 = 1 - Variable_115;

            // -
            float Variable_118; // - output 0
            Variable_118 = Variable_116 - Variable_117;

            // 1 - X
            float Variable_71; // 1 - X output 0
            Variable_71 = 1 - Variable_127;

            // PlainsNoiseStrengthCurve
            float Variable_77; // PlainsNoiseStrengthCurve output 0
            Variable_77 = PlainsNoiseStrength.Eval(Variable_35);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_128; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_128 = FMath::Clamp<float>(Variable_77, 0.000000, 1.000000);

            // *
            float Variable_72; // * output 0
            Variable_72 = Variable_118 * ConstantsCache.Variable_73 * Variable_71 * Variable_128;

            // Max (float)
            float Variable_113; // Max (float) output 0
            Variable_113 = FVoxelNodeFunctions::Max<float>(Variable_129, float(0.0f));

            // *
            float Variable_93; // * output 0
            Variable_93 = Variable_113 * float(-1.0f) * ConstantsCache.Variable_94;

            // +
            float Variable_34; // + output 0
            Variable_34 = Variable_40 + Variable_43 + Variable_49 + Variable_65 + Variable_72 + Variable_93;

            // *
            float Variable_133; // * output 0
            Variable_133 = Variable_34 * ConstantsCache.Variable_130;

            // -
            float Variable_33; // - output 0
            Variable_33 = ConstantsCache.Variable_131 - Variable_133;

            // -
            float Variable_4; // - output 0
            Variable_4 = Variable_33 - Variable_31;

            // -
            float Variable_7; // - output 0
            Variable_7 = Variable_31 - ConstantsCache.Variable_6;

            // Max (float)
            float Variable_8; // Max (float) output 0
            Variable_8 = FVoxelNodeFunctions::Max<float>(Variable_4, Variable_7);

            // -
            float Variable_19; // - output 0
            Variable_19 = Variable_8 - float(1.0f);

            // Max (float)
            float Variable_18; // Max (float) output 0
            Variable_18 = FVoxelNodeFunctions::Max<float>(Variable_36, float(0.0f));

            // *
            float Variable_20; // * output 0
            Variable_20 = Variable_18 * ConstantsCache.Variable_22;

            // Min (float)
            float Variable_21; // Min (float) output 0
            Variable_21 = FVoxelNodeFunctions::Min<float>(Variable_20, float(1.0f));

            // *
            float Variable_16; // * output 0
            Variable_16 = Variable_19 * Variable_21;

            // +
            float Variable_17; // + output 0
            Variable_17 = Variable_16 + float(1.0f);

            GraphOutputs.Value = Variable_17;
            // BlendColors.Clamp
            float Variable_78; // BlendColors.Clamp output 0
            Variable_78 = FVoxelNodeFunctions::Clamp(Variable_118, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_159; // BlendColors.Lerp output 0
            Variable_159 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_86, ConstantsCache.Variable_79, Variable_78);

            // *
            float Variable_125; // * output 0
            Variable_125 = Variable_129 * float(10.0f);

            // BlendColors.Clamp
            float Variable_107; // BlendColors.Clamp output 0
            Variable_107 = FVoxelNodeFunctions::Clamp(Variable_125, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_167; // BlendColors.Lerp output 0
            Variable_167 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_120, ConstantsCache.Variable_96, Variable_107);

            // +
            float Variable_119; // + output 0
            Variable_119 = Variable_129 + float(0.3f);

            // BlendColors.Clamp
            float Variable_85; // BlendColors.Clamp output 0
            Variable_85 = FVoxelNodeFunctions::Clamp(Variable_119, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_163; // BlendColors.Lerp output 0
            Variable_163 = FVoxelNodeFunctions::Lerp(Variable_159, Variable_167, Variable_85);

            // BlendColors.Clamp
            float Variable_55; // BlendColors.Clamp output 0
            Variable_55 = FVoxelNodeFunctions::Clamp(Variable_64, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_151; // BlendColors.Lerp output 0
            Variable_151 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_60, ConstantsCache.Variable_67, Variable_55);

            // BlendColors.Clamp
            float Variable_27; // BlendColors.Clamp output 0
            Variable_27 = FVoxelNodeFunctions::Clamp(Variable_48, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_147; // BlendColors.Lerp output 0
            Variable_147 = FVoxelNodeFunctions::Lerp(Variable_151, ConstantsCache.Variable_56, Variable_27);

            // *
            float Variable_84; // * output 0
            Variable_84 = Variable_127 * float(3.0f);

            // Max (float)
            float Variable_90; // Max (float) output 0
            Variable_90 = FVoxelNodeFunctions::Max<float>(Variable_118, float(0.0f));

            // -
            float Variable_91; // - output 0
            Variable_91 = Variable_84 - Variable_90;

            // BlendColors.Clamp
            float Variable_66; // BlendColors.Clamp output 0
            Variable_66 = FVoxelNodeFunctions::Clamp(Variable_91, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_155; // BlendColors.Lerp output 0
            Variable_155 = FVoxelNodeFunctions::Lerp(Variable_163, Variable_147, Variable_66);

            // -
            float Variable_142; // - output 0
            Variable_142 = ConstantsCache.Variable_138 - Variable_31;

            // Clamp
            float Variable_136; // Clamp output 0
            Variable_136 = FVoxelNodeFunctions::Clamp(Variable_142, float(0.0f), float(1.0f));

            // Min (float)
            float Variable_137; // Min (float) output 0
            Variable_137 = FVoxelNodeFunctions::Min<float>(Variable_21, Variable_136);

            // BlendColors.Clamp
            float Variable_124; // BlendColors.Clamp output 0
            Variable_124 = FVoxelNodeFunctions::Clamp(Variable_137, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_171; // BlendColors.Lerp output 0
            Variable_171 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_143, Variable_155, Variable_124);

            // BlendColors.Lerp
            float Variable_160; // BlendColors.Lerp output 0
            Variable_160 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_87, ConstantsCache.Variable_80, Variable_78);

            // BlendColors.Lerp
            float Variable_168; // BlendColors.Lerp output 0
            Variable_168 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_121, ConstantsCache.Variable_97, Variable_107);

            // BlendColors.Lerp
            float Variable_164; // BlendColors.Lerp output 0
            Variable_164 = FVoxelNodeFunctions::Lerp(Variable_160, Variable_168, Variable_85);

            // BlendColors.Lerp
            float Variable_152; // BlendColors.Lerp output 0
            Variable_152 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_61, ConstantsCache.Variable_68, Variable_55);

            // BlendColors.Lerp
            float Variable_148; // BlendColors.Lerp output 0
            Variable_148 = FVoxelNodeFunctions::Lerp(Variable_152, ConstantsCache.Variable_57, Variable_27);

            // BlendColors.Lerp
            float Variable_156; // BlendColors.Lerp output 0
            Variable_156 = FVoxelNodeFunctions::Lerp(Variable_164, Variable_148, Variable_66);

            // BlendColors.Lerp
            float Variable_172; // BlendColors.Lerp output 0
            Variable_172 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_144, Variable_156, Variable_124);

            // BlendColors.Lerp
            float Variable_161; // BlendColors.Lerp output 0
            Variable_161 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_88, ConstantsCache.Variable_81, Variable_78);

            // BlendColors.Lerp
            float Variable_169; // BlendColors.Lerp output 0
            Variable_169 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_122, ConstantsCache.Variable_98, Variable_107);

            // BlendColors.Lerp
            float Variable_165; // BlendColors.Lerp output 0
            Variable_165 = FVoxelNodeFunctions::Lerp(Variable_161, Variable_169, Variable_85);

            // BlendColors.Lerp
            float Variable_153; // BlendColors.Lerp output 0
            Variable_153 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_62, ConstantsCache.Variable_69, Variable_55);

            // BlendColors.Lerp
            float Variable_149; // BlendColors.Lerp output 0
            Variable_149 = FVoxelNodeFunctions::Lerp(Variable_153, ConstantsCache.Variable_58, Variable_27);

            // BlendColors.Lerp
            float Variable_157; // BlendColors.Lerp output 0
            Variable_157 = FVoxelNodeFunctions::Lerp(Variable_165, Variable_149, Variable_66);

            // BlendColors.Lerp
            float Variable_173; // BlendColors.Lerp output 0
            Variable_173 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_145, Variable_157, Variable_124);

            // BlendColors.Lerp
            float Variable_162; // BlendColors.Lerp output 0
            Variable_162 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_89, ConstantsCache.Variable_82, Variable_78);

            // BlendColors.Lerp
            float Variable_170; // BlendColors.Lerp output 0
            Variable_170 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_123, ConstantsCache.Variable_99, Variable_107);

            // BlendColors.Lerp
            float Variable_166; // BlendColors.Lerp output 0
            Variable_166 = FVoxelNodeFunctions::Lerp(Variable_162, Variable_170, Variable_85);

            // BlendColors.Lerp
            float Variable_154; // BlendColors.Lerp output 0
            Variable_154 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_63, ConstantsCache.Variable_70, Variable_55);

            // BlendColors.Lerp
            float Variable_150; // BlendColors.Lerp output 0
            Variable_150 = FVoxelNodeFunctions::Lerp(Variable_154, ConstantsCache.Variable_59, Variable_27);

            // BlendColors.Lerp
            float Variable_158; // BlendColors.Lerp output 0
            Variable_158 = FVoxelNodeFunctions::Lerp(Variable_166, Variable_150, Variable_66);

            // BlendColors.Lerp
            float Variable_174; // BlendColors.Lerp output 0
            Variable_174 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_146, Variable_158, Variable_124);

            GraphOutputs.Material.SetColor(FLinearColor(Variable_171, Variable_172, Variable_173, Variable_174));
        }

    };
    struct FLocalComputeStruct_LocalUpVectorXUpVectorYUpVectorZ_LOD0
    {
        struct FVoxelGraphOutputs
        {
            float& UpVectorX;
            float& UpVectorY;
            float& UpVectorZ;
        };
        struct FVoxelConstantsCache
        {
        };
        struct FVoxelCache
        {
        };

        FLocalComputeStruct_LocalUpVectorXUpVectorYUpVectorZ_LOD0(const float& InScale, const float& InPlainsNoiseHeight, const float& InRingEdgesHardness, const float& InWidth_in_Degrees, const float& InRiverDepth, const float& InThickness, const float& InBaseHeight, const float& InBaseNoiseHeight, const float& InBaseNoiseFrquency, const float& InMountainsNoiseHeight, const float& InRadius, const float& InRiverWidth, const float& InPlainsNoiseFrequency, const float& InMountainsNoiseFrequency, const FRichCurve& InRingShape, const FRichCurve& InMoutainsMask, const FRichCurve& InRiverMask, const FRichCurve& InPlainsNoiseStrength, const FLinearColor& InPlainsColorLow, const FLinearColor& InRiverColor, const FLinearColor& InBeachColor, const FLinearColor& InMountainsColorHigh, const FLinearColor& InMountainsColorLowLow, const FLinearColor& InMountainsColorLowHigh, const FLinearColor& InPlainsColorHigh, const FLinearColor& InRingOuterColor)
            : Scale(InScale)
            , PlainsNoiseHeight(InPlainsNoiseHeight)
            , RingEdgesHardness(InRingEdgesHardness)
            , Width_in_Degrees(InWidth_in_Degrees)
            , RiverDepth(InRiverDepth)
            , Thickness(InThickness)
            , BaseHeight(InBaseHeight)
            , BaseNoiseHeight(InBaseNoiseHeight)
            , BaseNoiseFrquency(InBaseNoiseFrquency)
            , MountainsNoiseHeight(InMountainsNoiseHeight)
            , Radius(InRadius)
            , RiverWidth(InRiverWidth)
            , PlainsNoiseFrequency(InPlainsNoiseFrequency)
            , MountainsNoiseFrequency(InMountainsNoiseFrequency)
            , RingShape(InRingShape)
            , MoutainsMask(InMoutainsMask)
            , RiverMask(InRiverMask)
            , PlainsNoiseStrength(InPlainsNoiseStrength)
            , PlainsColorLow(InPlainsColorLow)
            , RiverColor(InRiverColor)
            , BeachColor(InBeachColor)
            , MountainsColorHigh(InMountainsColorHigh)
            , MountainsColorLowLow(InMountainsColorLowLow)
            , MountainsColorLowHigh(InMountainsColorLowHigh)
            , PlainsColorHigh(InPlainsColorHigh)
            , RingOuterColor(InRingOuterColor)
        {
        }

        void Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            FVoxelCache Cache;

            {
            }

            Function0_Init(InitStruct);

            {
            }
        }
        void ComputeX(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_X_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXY(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XY_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXYZ(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XYZ_Compute(GraphOutputs, Cache, Context);
        }
        void Get(const FVoxelContext&Context, float& UpVectorX, float& UpVectorY, float& UpVectorZ) const
        {
            FVoxelGraphOutputs GraphOutputs{UpVectorX, UpVectorY, UpVectorZ};
            Function0_Compute(GraphOutputs, Context);
        }

    private:
        FVoxelConstantsCache ConstantsCache;

        const float& Scale;
        const float& PlainsNoiseHeight;
        const float& RingEdgesHardness;
        const float& Width_in_Degrees;
        const float& RiverDepth;
        const float& Thickness;
        const float& BaseHeight;
        const float& BaseNoiseHeight;
        const float& BaseNoiseFrquency;
        const float& MountainsNoiseHeight;
        const float& Radius;
        const float& RiverWidth;
        const float& PlainsNoiseFrequency;
        const float& MountainsNoiseFrequency;
        const FRichCurve& RingShape;
        const FRichCurve& MoutainsMask;
        const FRichCurve& RiverMask;
        const FRichCurve& PlainsNoiseStrength;
        const FLinearColor& PlainsColorLow;
        const FLinearColor& RiverColor;
        const FLinearColor& BeachColor;
        const FLinearColor& MountainsColorHigh;
        const FLinearColor& MountainsColorLowLow;
        const FLinearColor& MountainsColorLowHigh;
        const FLinearColor& PlainsColorHigh;
        const FLinearColor& RingOuterColor;

        ///////////////////////////////////////////////////////////////////////
        //////////////////////////// Init functions ///////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
        }

        ///////////////////////////////////////////////////////////////////////
        ////////////////////////// Compute functions //////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_X_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
        }

        void Function0_XY_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
        }

        void Function0_XYZ_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
        }

        void Function0_Compute(FVoxelGraphOutputs& GraphOutputs, const FVoxelContext& Context) const
        {
        }

    };
    struct FLocalComputeStruct_LocalValueRangeAnalysis_LOD0
    {
        struct FVoxelGraphOutputs
        {
            TVoxelRange<float>& Value;
        };
        struct FVoxelConstantsCache
        {
            TVoxelRange<float> Variable_47; // MountainsNoiseHeight = 500.0 output 0
            TVoxelRange<float> Variable_50; // MountainsNoiseFrequency = 0.2 output 0
            TVoxelRange<float> Variable_22; // RingEdgesHardness = 10.0 output 0
            TVoxelRange<float> Variable_25; // PI.3.141593 output 0
            TVoxelRange<float> Variable_31; // Width in Degrees = 50.0 output 0
            TVoxelRange<float> Variable_58; // PlainsNoiseFrequency = 0.2 output 0
            TVoxelRange<float> Variable_5; // Radius = 7000.0 output 0
            TVoxelRange<float> Variable_38; // BaseHeight = 1000.0 output 0
            TVoxelRange<float> Variable_41; // BaseNoiseHeight = 250.0 output 0
            TVoxelRange<float> Variable_44; // BaseNoiseFrquency = 0.005 output 0
            TVoxelRange<float> Variable_72; // Scale = 10.0 output 0
            TVoxelRange<float> Variable_76; // Thickness = 500.0 output 0
            TVoxelRange<float> Variable_55; // PlainsNoiseHeight = 250.0 output 0
            TVoxelRange<float> Variable_78; // PI.3.141593 output 0
            TVoxelRange<float> Variable_61; // RiverDepth = 100.0 output 0
            TVoxelRange<float> Variable_36; // / output 0
            TVoxelRange<float> Variable_73; // * output 0
            TVoxelRange<float> Variable_77; // * output 0
            TVoxelRange<float> Variable_6; // + output 0
            TVoxelRange<float> Variable_74; // / output 0
            TVoxelRange<float> Variable_35; // - output 0
        };
        struct FVoxelCache
        {
            TVoxelRange<float> Variable_0; // X output 0
            TVoxelRange<float> Variable_24; // X output 0
            TVoxelRange<float> Variable_1; // Y output 0
            TVoxelRange<float> Variable_29; // Y output 0
            TVoxelRange<float> Variable_23; // ATAN2 output 0
            TVoxelRange<float> Variable_26; // / output 0
            TVoxelRange<float> Variable_28; // * output 0
            TVoxelRange<float> Variable_43; // * output 0
            TVoxelRange<float> Variable_49; // * output 0
            TVoxelRange<float> Variable_57; // * output 0
        };

        FLocalComputeStruct_LocalValueRangeAnalysis_LOD0(const float& InScale, const float& InPlainsNoiseHeight, const float& InRingEdgesHardness, const float& InWidth_in_Degrees, const float& InRiverDepth, const float& InThickness, const float& InBaseHeight, const float& InBaseNoiseHeight, const float& InBaseNoiseFrquency, const float& InMountainsNoiseHeight, const float& InRadius, const float& InRiverWidth, const float& InPlainsNoiseFrequency, const float& InMountainsNoiseFrequency, const FRichCurve& InRingShape, const FRichCurve& InMoutainsMask, const FRichCurve& InRiverMask, const FRichCurve& InPlainsNoiseStrength, const FLinearColor& InPlainsColorLow, const FLinearColor& InRiverColor, const FLinearColor& InBeachColor, const FLinearColor& InMountainsColorHigh, const FLinearColor& InMountainsColorLowLow, const FLinearColor& InMountainsColorLowHigh, const FLinearColor& InPlainsColorHigh, const FLinearColor& InRingOuterColor)
            : Scale(InScale)
            , PlainsNoiseHeight(InPlainsNoiseHeight)
            , RingEdgesHardness(InRingEdgesHardness)
            , Width_in_Degrees(InWidth_in_Degrees)
            , RiverDepth(InRiverDepth)
            , Thickness(InThickness)
            , BaseHeight(InBaseHeight)
            , BaseNoiseHeight(InBaseNoiseHeight)
            , BaseNoiseFrquency(InBaseNoiseFrquency)
            , MountainsNoiseHeight(InMountainsNoiseHeight)
            , Radius(InRadius)
            , RiverWidth(InRiverWidth)
            , PlainsNoiseFrequency(InPlainsNoiseFrequency)
            , MountainsNoiseFrequency(InMountainsNoiseFrequency)
            , RingShape(InRingShape)
            , MoutainsMask(InMoutainsMask)
            , RiverMask(InRiverMask)
            , PlainsNoiseStrength(InPlainsNoiseStrength)
            , PlainsColorLow(InPlainsColorLow)
            , RiverColor(InRiverColor)
            , BeachColor(InBeachColor)
            , MountainsColorHigh(InMountainsColorHigh)
            , MountainsColorLowLow(InMountainsColorLowLow)
            , MountainsColorLowHigh(InMountainsColorLowHigh)
            , PlainsColorHigh(InPlainsColorHigh)
            , RingOuterColor(InRingOuterColor)
        {
        }

        void Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            FVoxelCache Cache;

            {
            }

            Function0_Init(InitStruct);

            {
                // MountainsNoiseHeight = 500.0
                ConstantsCache.Variable_47 = MountainsNoiseHeight;

                // MountainsNoiseFrequency = 0.2
                ConstantsCache.Variable_50 = MountainsNoiseFrequency;

                // RingEdgesHardness = 10.0
                ConstantsCache.Variable_22 = RingEdgesHardness;

                // PI.3.141593
                ConstantsCache.Variable_25 = 3.141593;

                // Width in Degrees = 50.0
                ConstantsCache.Variable_31 = Width_in_Degrees;

                // PlainsNoiseFrequency = 0.2
                ConstantsCache.Variable_58 = PlainsNoiseFrequency;

                // Radius = 7000.0
                ConstantsCache.Variable_5 = Radius;

                // BaseHeight = 1000.0
                ConstantsCache.Variable_38 = BaseHeight;

                // BaseNoiseHeight = 250.0
                ConstantsCache.Variable_41 = BaseNoiseHeight;

                // BaseNoiseFrquency = 0.005
                ConstantsCache.Variable_44 = BaseNoiseFrquency;

                // Scale = 10.0
                ConstantsCache.Variable_72 = Scale;

                // Thickness = 500.0
                ConstantsCache.Variable_76 = Thickness;

                // PlainsNoiseHeight = 250.0
                ConstantsCache.Variable_55 = PlainsNoiseHeight;

                // PI.3.141593
                ConstantsCache.Variable_78 = 3.141593;

                // RiverDepth = 100.0
                ConstantsCache.Variable_61 = RiverDepth;

                // /
                ConstantsCache.Variable_36 = ConstantsCache.Variable_31 / TVoxelRange<float>(360.0f);

                // *
                ConstantsCache.Variable_73 = ConstantsCache.Variable_5 * ConstantsCache.Variable_72;

                // *
                ConstantsCache.Variable_77 = ConstantsCache.Variable_76 * ConstantsCache.Variable_72;

                // +
                ConstantsCache.Variable_6 = ConstantsCache.Variable_73 + ConstantsCache.Variable_77;

                // /
                ConstantsCache.Variable_74 = ConstantsCache.Variable_73 / ConstantsCache.Variable_72;

                // -
                ConstantsCache.Variable_35 = TVoxelRange<float>(0.5f) - ConstantsCache.Variable_36;

            }
        }
        void Get(const FVoxelContextRange&Context, TVoxelRange<float>& Value) const
        {
            FVoxelGraphOutputs GraphOutputs{Value};
            Function0_Compute(GraphOutputs, Context);
        }

    private:
        FVoxelConstantsCache ConstantsCache;
        FastNoise _2D_Simplex_Noise_Fractal_15565_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15566_Noise;
        FastNoise _2D_Perlin_Noise_7433_Noise;
        FastNoise _2D_Simplex_Noise_8753_Noise;

        const float& Scale;
        const float& PlainsNoiseHeight;
        const float& RingEdgesHardness;
        const float& Width_in_Degrees;
        const float& RiverDepth;
        const float& Thickness;
        const float& BaseHeight;
        const float& BaseNoiseHeight;
        const float& BaseNoiseFrquency;
        const float& MountainsNoiseHeight;
        const float& Radius;
        const float& RiverWidth;
        const float& PlainsNoiseFrequency;
        const float& MountainsNoiseFrequency;
        const FRichCurve& RingShape;
        const FRichCurve& MoutainsMask;
        const FRichCurve& RiverMask;
        const FRichCurve& PlainsNoiseStrength;
        const FLinearColor& PlainsColorLow;
        const FLinearColor& RiverColor;
        const FLinearColor& BeachColor;
        const FLinearColor& MountainsColorHigh;
        const FLinearColor& MountainsColorLowLow;
        const FLinearColor& MountainsColorLowHigh;
        const FLinearColor& PlainsColorHigh;
        const FLinearColor& RingOuterColor;

        ///////////////////////////////////////////////////////////////////////
        //////////////////////////// Init functions ///////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15565_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15565_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15565_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15565_Noise.SetFractalOctaves(5);
            _2D_Simplex_Noise_Fractal_15565_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15565_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15565_Noise.SetFractalType(FastNoise::FractalType::FBM);

            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15566_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15566_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15566_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15566_Noise.SetFractalOctaves(8);
            _2D_Simplex_Noise_Fractal_15566_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15566_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15566_Noise.SetFractalType(FastNoise::FractalType::FBM);

            // Init of 2D Perlin Noise
            _2D_Perlin_Noise_7433_Noise.SetSeed(Seed(1338));
            _2D_Perlin_Noise_7433_Noise.SetFrequency(0.1);
            _2D_Perlin_Noise_7433_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8753_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_8753_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_8753_Noise.SetInterp(FastNoise::Interp::Quintic);

        }

        ///////////////////////////////////////////////////////////////////////
        ////////////////////////// Compute functions //////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_Compute(FVoxelGraphOutputs& GraphOutputs, const FVoxelContextRange& Context) const
        {
            // Static Clamp: 0.0 <= X <= 1.0
            TVoxelRange<float> Variable_68; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_68 = { 0.000000f, 1.000000f };

            // *
            TVoxelRange<float> Variable_37; // * output 0
            Variable_37 = Variable_68 * ConstantsCache.Variable_38;

            // Z
            TVoxelRange<float> Variable_12; // Z output 0
            Variable_12 = Context.Z;

            // X
            TVoxelRange<float> Variable_0; // X output 0
            Variable_0 = Context.X;

            // Y
            TVoxelRange<float> Variable_1; // Y output 0
            Variable_1 = Context.Y;

            // Z
            TVoxelRange<float> Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            TVoxelRange<float> Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Variable_0, Variable_1, Variable_2);

            // +
            TVoxelRange<float> Variable_30; // + output 0
            Variable_30 = Variable_3 + TVoxelRange<float>(0.001f);

            // /
            TVoxelRange<float> Variable_13; // / output 0
            Variable_13 = Variable_12 / Variable_30;

            // ACOS
            TVoxelRange<float> Variable_14; // ACOS output 0
            Variable_14 = FVoxelNodeFunctions::Acos(Variable_13);

            // /
            TVoxelRange<float> Variable_10; // / output 0
            Variable_10 = Variable_14 / ConstantsCache.Variable_78;

            // *
            TVoxelRange<float> Variable_27; // * output 0
            Variable_27 = ConstantsCache.Variable_74 * Variable_10;

            // *
            TVoxelRange<float> Variable_42; // * output 0
            Variable_42 = Variable_27 * ConstantsCache.Variable_44;

            // Y
            TVoxelRange<float> Variable_29; // Y output 0
            Variable_29 = Context.Y;

            // X
            TVoxelRange<float> Variable_24; // X output 0
            Variable_24 = Context.X;

            // ATAN2
            TVoxelRange<float> Variable_23; // ATAN2 output 0
            Variable_23 = FVoxelNodeFunctions::Atan2(Variable_29, Variable_24);

            // /
            TVoxelRange<float> Variable_26; // / output 0
            Variable_26 = Variable_23 / ConstantsCache.Variable_25;

            // *
            TVoxelRange<float> Variable_28; // * output 0
            Variable_28 = ConstantsCache.Variable_74 * Variable_26;

            // *
            TVoxelRange<float> Variable_43; // * output 0
            Variable_43 = Variable_28 * ConstantsCache.Variable_44;

            // 2D Simplex Noise Fractal
            TVoxelRange<float> Variable_39; // 2D Simplex Noise Fractal output 0
            Variable_39 = { -1, 1 };

            // *
            TVoxelRange<float> Variable_40; // * output 0
            Variable_40 = Variable_39 * ConstantsCache.Variable_41;

            // *
            TVoxelRange<float> Variable_48; // * output 0
            Variable_48 = Variable_27 * ConstantsCache.Variable_50;

            // *
            TVoxelRange<float> Variable_49; // * output 0
            Variable_49 = Variable_28 * ConstantsCache.Variable_50;

            // 2D Simplex Noise Fractal
            TVoxelRange<float> Variable_45; // 2D Simplex Noise Fractal output 0
            Variable_45 = { -1, 1 };

            // Static Clamp: 0.0 <= X <= 1.0
            TVoxelRange<float> Variable_69; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_69 = { 0.000000f, 1.000000f };

            // *
            TVoxelRange<float> Variable_46; // * output 0
            Variable_46 = Variable_45 * ConstantsCache.Variable_47 * Variable_69;

            // 2D Perlin Noise
            TVoxelRange<float> Variable_51; // 2D Perlin Noise output 0
            Variable_51 = { -1, 1 };

            // *
            TVoxelRange<float> Variable_52; // * output 0
            Variable_52 = ConstantsCache.Variable_47 * Variable_69 * Variable_51 * TVoxelRange<float>(0.1f);

            // *
            TVoxelRange<float> Variable_56; // * output 0
            Variable_56 = Variable_27 * ConstantsCache.Variable_58;

            // *
            TVoxelRange<float> Variable_57; // * output 0
            Variable_57 = Variable_28 * ConstantsCache.Variable_58;

            // 2D Simplex Noise
            TVoxelRange<float> Variable_59; // 2D Simplex Noise output 0
            Variable_59 = { -1, 1 };

            // Static Clamp: -1.0 <= X <= 1.0
            TVoxelRange<float> Variable_71; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_71 = { -1.000000f, 1.000000f };

            // Min (float)
            TVoxelRange<float> Variable_63; // Min (float) output 0
            Variable_63 = FVoxelNodeFunctions::Min<float>(Variable_71, TVoxelRange<float>(0.0f));

            // *
            TVoxelRange<float> Variable_64; // * output 0
            Variable_64 = Variable_63 * TVoxelRange<float>(-1.0f);

            // *
            TVoxelRange<float> Variable_65; // * output 0
            Variable_65 = Variable_59 * Variable_64;

            // 1 - X
            TVoxelRange<float> Variable_66; // 1 - X output 0
            Variable_66 = 1 - Variable_64;

            // -
            TVoxelRange<float> Variable_67; // - output 0
            Variable_67 = Variable_65 - Variable_66;

            // 1 - X
            TVoxelRange<float> Variable_53; // 1 - X output 0
            Variable_53 = 1 - Variable_69;

            // Static Clamp: 0.0 <= X <= 1.0
            TVoxelRange<float> Variable_70; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_70 = { 0.000000f, 1.000000f };

            // *
            TVoxelRange<float> Variable_54; // * output 0
            Variable_54 = Variable_67 * ConstantsCache.Variable_55 * Variable_53 * Variable_70;

            // Max (float)
            TVoxelRange<float> Variable_62; // Max (float) output 0
            Variable_62 = FVoxelNodeFunctions::Max<float>(Variable_71, TVoxelRange<float>(0.0f));

            // *
            TVoxelRange<float> Variable_60; // * output 0
            Variable_60 = Variable_62 * TVoxelRange<float>(-1.0f) * ConstantsCache.Variable_61;

            // +
            TVoxelRange<float> Variable_33; // + output 0
            Variable_33 = Variable_37 + Variable_40 + Variable_46 + Variable_52 + Variable_54 + Variable_60;

            // *
            TVoxelRange<float> Variable_75; // * output 0
            Variable_75 = Variable_33 * ConstantsCache.Variable_72;

            // -
            TVoxelRange<float> Variable_32; // - output 0
            Variable_32 = ConstantsCache.Variable_73 - Variable_75;

            // -
            TVoxelRange<float> Variable_4; // - output 0
            Variable_4 = Variable_32 - Variable_30;

            // -
            TVoxelRange<float> Variable_7; // - output 0
            Variable_7 = Variable_30 - ConstantsCache.Variable_6;

            // Max (float)
            TVoxelRange<float> Variable_8; // Max (float) output 0
            Variable_8 = FVoxelNodeFunctions::Max<float>(Variable_4, Variable_7);

            // -
            TVoxelRange<float> Variable_19; // - output 0
            Variable_19 = Variable_8 - TVoxelRange<float>(1.0f);

            // 1 - X
            TVoxelRange<float> Variable_11; // 1 - X output 0
            Variable_11 = 1 - Variable_10;

            // Min (float)
            TVoxelRange<float> Variable_9; // Min (float) output 0
            Variable_9 = FVoxelNodeFunctions::Min<float>(Variable_10, Variable_11);

            // -
            TVoxelRange<float> Variable_15; // - output 0
            Variable_15 = Variable_9 - ConstantsCache.Variable_35;

            // /
            TVoxelRange<float> Variable_34; // / output 0
            Variable_34 = Variable_15 / ConstantsCache.Variable_36;

            // Max (float)
            TVoxelRange<float> Variable_18; // Max (float) output 0
            Variable_18 = FVoxelNodeFunctions::Max<float>(Variable_34, TVoxelRange<float>(0.0f));

            // *
            TVoxelRange<float> Variable_20; // * output 0
            Variable_20 = Variable_18 * ConstantsCache.Variable_22;

            // Min (float)
            TVoxelRange<float> Variable_21; // Min (float) output 0
            Variable_21 = FVoxelNodeFunctions::Min<float>(Variable_20, TVoxelRange<float>(1.0f));

            // *
            TVoxelRange<float> Variable_16; // * output 0
            Variable_16 = Variable_19 * Variable_21;

            // +
            TVoxelRange<float> Variable_17; // + output 0
            Variable_17 = Variable_16 + TVoxelRange<float>(1.0f);

            GraphOutputs.Value = Variable_17;
        }

    };
    struct FLocalComputeStruct_LocalValueCache2DCache_LOD0
    {
        struct FVoxelGraphOutputs
        {
            float& Value;
        };
        struct FVoxelConstantsCache
        {
            float Variable_52; // MountainsNoiseFrequency = 0.2 output 0
            float Variable_58; // PlainsNoiseHeight = 250.0 output 0
            float Variable_22; // RingEdgesHardness = 10.0 output 0
            float Variable_25; // PI.3.141593 output 0
            float Variable_31; // Width in Degrees = 50.0 output 0
            float Variable_66; // RiverDepth = 100.0 output 0
            float Variable_96; // Thickness = 500.0 output 0
            float Variable_40; // BaseHeight = 1000.0 output 0
            float Variable_43; // BaseNoiseHeight = 250.0 output 0
            float Variable_46; // BaseNoiseFrquency = 0.005 output 0
            float Variable_49; // MountainsNoiseHeight = 500.0 output 0
            float Variable_5; // Radius = 7000.0 output 0
            float Variable_95; // RiverWidth = 1.0 output 0
            float Variable_61; // PlainsNoiseFrequency = 0.2 output 0
            float Variable_98; // PI.3.141593 output 0
            float Variable_67; // PI.3.141593 output 0
            float Variable_90; // Scale = 10.0 output 0
            float Variable_91; // * output 0
            float Variable_37; // / output 0
            float Variable_97; // * output 0
            float Variable_6; // + output 0
            float Variable_92; // / output 0
            float Variable_36; // - output 0
        };
        struct FVoxelCache
        {
            float Variable_0; // X output 0
            float Variable_24; // X output 0
            float Variable_1; // Y output 0
            float Variable_29; // Y output 0
            float Variable_23; // ATAN2 output 0
            float Variable_26; // / output 0
            float Variable_28; // * output 0
            float Variable_45; // * output 0
            float Variable_51; // * output 0
            float Variable_60; // * output 0
            float Variable_79; // 2D Simplex Noise output 0
            float Variable_76; // * output 0
        };

        FLocalComputeStruct_LocalValueCache2DCache_LOD0(const float& InScale, const float& InPlainsNoiseHeight, const float& InRingEdgesHardness, const float& InWidth_in_Degrees, const float& InRiverDepth, const float& InThickness, const float& InBaseHeight, const float& InBaseNoiseHeight, const float& InBaseNoiseFrquency, const float& InMountainsNoiseHeight, const float& InRadius, const float& InRiverWidth, const float& InPlainsNoiseFrequency, const float& InMountainsNoiseFrequency, const FRichCurve& InRingShape, const FRichCurve& InMoutainsMask, const FRichCurve& InRiverMask, const FRichCurve& InPlainsNoiseStrength, const FLinearColor& InPlainsColorLow, const FLinearColor& InRiverColor, const FLinearColor& InBeachColor, const FLinearColor& InMountainsColorHigh, const FLinearColor& InMountainsColorLowLow, const FLinearColor& InMountainsColorLowHigh, const FLinearColor& InPlainsColorHigh, const FLinearColor& InRingOuterColor)
            : Scale(InScale)
            , PlainsNoiseHeight(InPlainsNoiseHeight)
            , RingEdgesHardness(InRingEdgesHardness)
            , Width_in_Degrees(InWidth_in_Degrees)
            , RiverDepth(InRiverDepth)
            , Thickness(InThickness)
            , BaseHeight(InBaseHeight)
            , BaseNoiseHeight(InBaseNoiseHeight)
            , BaseNoiseFrquency(InBaseNoiseFrquency)
            , MountainsNoiseHeight(InMountainsNoiseHeight)
            , Radius(InRadius)
            , RiverWidth(InRiverWidth)
            , PlainsNoiseFrequency(InPlainsNoiseFrequency)
            , MountainsNoiseFrequency(InMountainsNoiseFrequency)
            , RingShape(InRingShape)
            , MoutainsMask(InMoutainsMask)
            , RiverMask(InRiverMask)
            , PlainsNoiseStrength(InPlainsNoiseStrength)
            , PlainsColorLow(InPlainsColorLow)
            , RiverColor(InRiverColor)
            , BeachColor(InBeachColor)
            , MountainsColorHigh(InMountainsColorHigh)
            , MountainsColorLowLow(InMountainsColorLowLow)
            , MountainsColorLowHigh(InMountainsColorLowHigh)
            , PlainsColorHigh(InPlainsColorHigh)
            , RingOuterColor(InRingOuterColor)
        {
        }

        void Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            FVoxelCache Cache;

            {
            }

            Function0_Init(InitStruct);

            {
                // MountainsNoiseFrequency = 0.2
                ConstantsCache.Variable_52 = MountainsNoiseFrequency;

                // PlainsNoiseHeight = 250.0
                ConstantsCache.Variable_58 = PlainsNoiseHeight;

                // RingEdgesHardness = 10.0
                ConstantsCache.Variable_22 = RingEdgesHardness;

                // PI.3.141593
                ConstantsCache.Variable_25 = 3.141593;

                // Width in Degrees = 50.0
                ConstantsCache.Variable_31 = Width_in_Degrees;

                // RiverDepth = 100.0
                ConstantsCache.Variable_66 = RiverDepth;

                // Thickness = 500.0
                ConstantsCache.Variable_96 = Thickness;

                // BaseHeight = 1000.0
                ConstantsCache.Variable_40 = BaseHeight;

                // BaseNoiseHeight = 250.0
                ConstantsCache.Variable_43 = BaseNoiseHeight;

                // BaseNoiseFrquency = 0.005
                ConstantsCache.Variable_46 = BaseNoiseFrquency;

                // MountainsNoiseHeight = 500.0
                ConstantsCache.Variable_49 = MountainsNoiseHeight;

                // Radius = 7000.0
                ConstantsCache.Variable_5 = Radius;

                // RiverWidth = 1.0
                ConstantsCache.Variable_95 = RiverWidth;

                // PlainsNoiseFrequency = 0.2
                ConstantsCache.Variable_61 = PlainsNoiseFrequency;

                // PI.3.141593
                ConstantsCache.Variable_98 = 3.141593;

                // PI.3.141593
                ConstantsCache.Variable_67 = 3.141593;

                // Scale = 10.0
                ConstantsCache.Variable_90 = Scale;

                // *
                ConstantsCache.Variable_91 = ConstantsCache.Variable_5 * ConstantsCache.Variable_90;

                // /
                ConstantsCache.Variable_37 = ConstantsCache.Variable_31 / float(360.0f);

                // *
                ConstantsCache.Variable_97 = ConstantsCache.Variable_96 * ConstantsCache.Variable_90;

                // +
                ConstantsCache.Variable_6 = ConstantsCache.Variable_91 + ConstantsCache.Variable_97;

                // /
                ConstantsCache.Variable_92 = ConstantsCache.Variable_91 / ConstantsCache.Variable_90;

                // -
                ConstantsCache.Variable_36 = float(0.5f) - ConstantsCache.Variable_37;

            }
        }
        void Get(const FVoxelContext&Context, float& Value) const
        {
            FVoxelGraphOutputs GraphOutputs{Value};
            Function0_Compute(GraphOutputs, Context);
        }

    private:
        FVoxelConstantsCache ConstantsCache;
        FastNoise _2D_Simplex_Noise_8754_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15567_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15568_Noise;
        FastNoise _2D_Perlin_Noise_7434_Noise;
        FastNoise _2D_Simplex_Noise_8755_Noise;

        const float& Scale;
        const float& PlainsNoiseHeight;
        const float& RingEdgesHardness;
        const float& Width_in_Degrees;
        const float& RiverDepth;
        const float& Thickness;
        const float& BaseHeight;
        const float& BaseNoiseHeight;
        const float& BaseNoiseFrquency;
        const float& MountainsNoiseHeight;
        const float& Radius;
        const float& RiverWidth;
        const float& PlainsNoiseFrequency;
        const float& MountainsNoiseFrequency;
        const FRichCurve& RingShape;
        const FRichCurve& MoutainsMask;
        const FRichCurve& RiverMask;
        const FRichCurve& PlainsNoiseStrength;
        const FLinearColor& PlainsColorLow;
        const FLinearColor& RiverColor;
        const FLinearColor& BeachColor;
        const FLinearColor& MountainsColorHigh;
        const FLinearColor& MountainsColorLowLow;
        const FLinearColor& MountainsColorLowHigh;
        const FLinearColor& PlainsColorHigh;
        const FLinearColor& RingOuterColor;

        ///////////////////////////////////////////////////////////////////////
        //////////////////////////// Init functions ///////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15567_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15567_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15567_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15567_Noise.SetFractalOctaves(5);
            _2D_Simplex_Noise_Fractal_15567_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15567_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15567_Noise.SetFractalType(FastNoise::FractalType::FBM);

            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15568_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15568_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15568_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15568_Noise.SetFractalOctaves(8);
            _2D_Simplex_Noise_Fractal_15568_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15568_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15568_Noise.SetFractalType(FastNoise::FractalType::FBM);

            // Init of 2D Perlin Noise
            _2D_Perlin_Noise_7434_Noise.SetSeed(Seed(1338));
            _2D_Perlin_Noise_7434_Noise.SetFrequency(0.1);
            _2D_Perlin_Noise_7434_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8755_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_8755_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_8755_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8754_Noise.SetSeed(Seed(1000));
            _2D_Simplex_Noise_8754_Noise.SetFrequency(0.001);
            _2D_Simplex_Noise_8754_Noise.SetInterp(FastNoise::Interp::Quintic);

        }

        ///////////////////////////////////////////////////////////////////////
        ////////////////////////// Compute functions //////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_Compute(FVoxelGraphOutputs& GraphOutputs, const FVoxelContext& Context) const
        {
            // Z
            float Variable_12; // Z output 0
            Variable_12 = Context.Z;

            // X
            float Variable_0; // X output 0
            Variable_0 = Context.X;

            // Y
            float Variable_1; // Y output 0
            Variable_1 = Context.Y;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Variable_0, Variable_1, Variable_2);

            // +
            float Variable_30; // + output 0
            Variable_30 = Variable_3 + float(0.001f);

            // /
            float Variable_13; // / output 0
            Variable_13 = Variable_12 / Variable_30;

            // ACOS
            float Variable_14; // ACOS output 0
            Variable_14 = FVoxelNodeFunctions::Acos(Variable_13);

            // /
            float Variable_10; // / output 0
            Variable_10 = Variable_14 / ConstantsCache.Variable_98;

            // 1 - X
            float Variable_11; // 1 - X output 0
            Variable_11 = 1 - Variable_10;

            // Min (float)
            float Variable_9; // Min (float) output 0
            Variable_9 = FVoxelNodeFunctions::Min<float>(Variable_10, Variable_11);

            // -
            float Variable_15; // - output 0
            Variable_15 = Variable_9 - ConstantsCache.Variable_36;

            // /
            float Variable_35; // / output 0
            Variable_35 = Variable_15 / ConstantsCache.Variable_37;

            // 1 - X
            float Variable_34; // 1 - X output 0
            Variable_34 = 1 - Variable_35;

            // RingCurve
            float Variable_38; // RingCurve output 0
            Variable_38 = RingShape.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_86; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_86 = FMath::Clamp<float>(Variable_38, 0.000000, 1.000000);

            // *
            float Variable_39; // * output 0
            Variable_39 = Variable_86 * ConstantsCache.Variable_40;

            // *
            float Variable_27; // * output 0
            Variable_27 = ConstantsCache.Variable_92 * Variable_10;

            // *
            float Variable_44; // * output 0
            Variable_44 = Variable_27 * ConstantsCache.Variable_46;

            // Y
            float Variable_29; // Y output 0
            Variable_29 = Context.Y;

            // X
            float Variable_24; // X output 0
            Variable_24 = Context.X;

            // ATAN2
            float Variable_23; // ATAN2 output 0
            Variable_23 = FVoxelNodeFunctions::Atan2(Variable_29, Variable_24);

            // /
            float Variable_26; // / output 0
            Variable_26 = Variable_23 / ConstantsCache.Variable_25;

            // *
            float Variable_28; // * output 0
            Variable_28 = ConstantsCache.Variable_92 * Variable_26;

            // *
            float Variable_45; // * output 0
            Variable_45 = Variable_28 * ConstantsCache.Variable_46;

            // 2D Simplex Noise Fractal
            float Variable_41; // 2D Simplex Noise Fractal output 0
            Variable_41 = _2D_Simplex_Noise_Fractal_15567_Noise.GetSimplexFractal(Variable_44, Variable_45);

            // *
            float Variable_42; // * output 0
            Variable_42 = Variable_41 * ConstantsCache.Variable_43;

            // *
            float Variable_50; // * output 0
            Variable_50 = Variable_27 * ConstantsCache.Variable_52;

            // *
            float Variable_51; // * output 0
            Variable_51 = Variable_28 * ConstantsCache.Variable_52;

            // 2D Simplex Noise Fractal
            float Variable_47; // 2D Simplex Noise Fractal output 0
            Variable_47 = _2D_Simplex_Noise_Fractal_15568_Noise.GetSimplexFractal(Variable_50, Variable_51);

            // MountainsCurve
            float Variable_53; // MountainsCurve output 0
            Variable_53 = MoutainsMask.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_87; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_87 = FMath::Clamp<float>(Variable_53, 0.000000, 1.000000);

            // *
            float Variable_48; // * output 0
            Variable_48 = Variable_47 * ConstantsCache.Variable_49 * Variable_87;

            // 2D Perlin Noise
            float Variable_54; // 2D Perlin Noise output 0
            Variable_54 = _2D_Perlin_Noise_7434_Noise.GetPerlin(Variable_50, Variable_51);

            // *
            float Variable_55; // * output 0
            Variable_55 = ConstantsCache.Variable_49 * Variable_87 * Variable_54 * float(0.1f);

            // *
            float Variable_59; // * output 0
            Variable_59 = Variable_27 * ConstantsCache.Variable_61;

            // *
            float Variable_60; // * output 0
            Variable_60 = Variable_28 * ConstantsCache.Variable_61;

            // 2D Simplex Noise
            float Variable_63; // 2D Simplex Noise output 0
            Variable_63 = _2D_Simplex_Noise_8755_Noise.GetSimplex(Variable_59, Variable_60);

            // Z
            float Variable_72; // Z output 0
            Variable_72 = Context.Z;

            // /
            float Variable_73; // / output 0
            Variable_73 = Variable_72 / Variable_30;

            // 2D Simplex Noise
            float Variable_79; // 2D Simplex Noise output 0
            Variable_79 = _2D_Simplex_Noise_8754_Noise.GetSimplex(Variable_28, Variable_28);

            // *
            float Variable_76; // * output 0
            Variable_76 = Variable_79 * float(0.1f);

            // +
            float Variable_75; // + output 0
            Variable_75 = Variable_73 + Variable_76;

            // ACOS
            float Variable_74; // ACOS output 0
            Variable_74 = FVoxelNodeFunctions::Acos(Variable_75);

            // /
            float Variable_71; // / output 0
            Variable_71 = Variable_74 / ConstantsCache.Variable_67;

            // 1 - X
            float Variable_69; // 1 - X output 0
            Variable_69 = 1 - Variable_71;

            // Min (float)
            float Variable_68; // Min (float) output 0
            Variable_68 = FVoxelNodeFunctions::Min<float>(Variable_71, Variable_69);

            // /
            float Variable_70; // / output 0
            Variable_70 = Variable_68 / float(0.5f);

            // 1 - X
            float Variable_77; // 1 - X output 0
            Variable_77 = 1 - Variable_70;

            // *
            float Variable_78; // * output 0
            Variable_78 = Variable_77 * float(20.0f);

            // /
            float Variable_94; // / output 0
            Variable_94 = Variable_78 / ConstantsCache.Variable_95;

            // RiverCurve
            float Variable_64; // RiverCurve output 0
            Variable_64 = RiverMask.Eval(Variable_94);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_89; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_89 = FMath::Clamp<float>(Variable_64, -1.000000, 1.000000);

            // Min (float)
            float Variable_81; // Min (float) output 0
            Variable_81 = FVoxelNodeFunctions::Min<float>(Variable_89, float(0.0f));

            // *
            float Variable_82; // * output 0
            Variable_82 = Variable_81 * float(-1.0f);

            // *
            float Variable_83; // * output 0
            Variable_83 = Variable_63 * Variable_82;

            // 1 - X
            float Variable_84; // 1 - X output 0
            Variable_84 = 1 - Variable_82;

            // -
            float Variable_85; // - output 0
            Variable_85 = Variable_83 - Variable_84;

            // 1 - X
            float Variable_56; // 1 - X output 0
            Variable_56 = 1 - Variable_87;

            // PlainsNoiseStrengthCurve
            float Variable_62; // PlainsNoiseStrengthCurve output 0
            Variable_62 = PlainsNoiseStrength.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_88; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_88 = FMath::Clamp<float>(Variable_62, 0.000000, 1.000000);

            // *
            float Variable_57; // * output 0
            Variable_57 = Variable_85 * ConstantsCache.Variable_58 * Variable_56 * Variable_88;

            // Max (float)
            float Variable_80; // Max (float) output 0
            Variable_80 = FVoxelNodeFunctions::Max<float>(Variable_89, float(0.0f));

            // *
            float Variable_65; // * output 0
            Variable_65 = Variable_80 * float(-1.0f) * ConstantsCache.Variable_66;

            // +
            float Variable_33; // + output 0
            Variable_33 = Variable_39 + Variable_42 + Variable_48 + Variable_55 + Variable_57 + Variable_65;

            // *
            float Variable_93; // * output 0
            Variable_93 = Variable_33 * ConstantsCache.Variable_90;

            // -
            float Variable_32; // - output 0
            Variable_32 = ConstantsCache.Variable_91 - Variable_93;

            // -
            float Variable_4; // - output 0
            Variable_4 = Variable_32 - Variable_30;

            // -
            float Variable_7; // - output 0
            Variable_7 = Variable_30 - ConstantsCache.Variable_6;

            // Max (float)
            float Variable_8; // Max (float) output 0
            Variable_8 = FVoxelNodeFunctions::Max<float>(Variable_4, Variable_7);

            // -
            float Variable_19; // - output 0
            Variable_19 = Variable_8 - float(1.0f);

            // Max (float)
            float Variable_18; // Max (float) output 0
            Variable_18 = FVoxelNodeFunctions::Max<float>(Variable_35, float(0.0f));

            // *
            float Variable_20; // * output 0
            Variable_20 = Variable_18 * ConstantsCache.Variable_22;

            // Min (float)
            float Variable_21; // Min (float) output 0
            Variable_21 = FVoxelNodeFunctions::Min<float>(Variable_20, float(1.0f));

            // *
            float Variable_16; // * output 0
            Variable_16 = Variable_19 * Variable_21;

            // +
            float Variable_17; // + output 0
            Variable_17 = Variable_16 + float(1.0f);

            GraphOutputs.Value = Variable_17;
        }

    };
    struct FLocalComputeStruct_LocalValueCache2DUsage_LOD0
    {
        struct FVoxelGraphOutputs
        {
            float& Value;
            float& Cache2DUsage;
        };
        struct FVoxelConstantsCache
        {
            float Variable_52; // MountainsNoiseFrequency = 0.2 output 0
            float Variable_58; // PlainsNoiseHeight = 250.0 output 0
            float Variable_22; // RingEdgesHardness = 10.0 output 0
            float Variable_25; // PI.3.141593 output 0
            float Variable_31; // Width in Degrees = 50.0 output 0
            float Variable_66; // RiverDepth = 100.0 output 0
            float Variable_96; // Thickness = 500.0 output 0
            float Variable_40; // BaseHeight = 1000.0 output 0
            float Variable_43; // BaseNoiseHeight = 250.0 output 0
            float Variable_46; // BaseNoiseFrquency = 0.005 output 0
            float Variable_49; // MountainsNoiseHeight = 500.0 output 0
            float Variable_5; // Radius = 7000.0 output 0
            float Variable_95; // RiverWidth = 1.0 output 0
            float Variable_61; // PlainsNoiseFrequency = 0.2 output 0
            float Variable_98; // PI.3.141593 output 0
            float Variable_67; // PI.3.141593 output 0
            float Variable_90; // Scale = 10.0 output 0
            float Variable_91; // * output 0
            float Variable_37; // / output 0
            float Variable_97; // * output 0
            float Variable_6; // + output 0
            float Variable_92; // / output 0
            float Variable_36; // - output 0
        };
        struct FVoxelCache
        {
            float Variable_0; // X output 0
            float Variable_24; // X output 0
            float Variable_1; // Y output 0
            float Variable_29; // Y output 0
            float Variable_23; // ATAN2 output 0
            float Variable_26; // / output 0
            float Variable_28; // * output 0
            float Variable_45; // * output 0
            float Variable_51; // * output 0
            float Variable_60; // * output 0
            float Variable_79; // 2D Simplex Noise output 0
            float Variable_76; // * output 0
        };

        FLocalComputeStruct_LocalValueCache2DUsage_LOD0(const float& InScale, const float& InPlainsNoiseHeight, const float& InRingEdgesHardness, const float& InWidth_in_Degrees, const float& InRiverDepth, const float& InThickness, const float& InBaseHeight, const float& InBaseNoiseHeight, const float& InBaseNoiseFrquency, const float& InMountainsNoiseHeight, const float& InRadius, const float& InRiverWidth, const float& InPlainsNoiseFrequency, const float& InMountainsNoiseFrequency, const FRichCurve& InRingShape, const FRichCurve& InMoutainsMask, const FRichCurve& InRiverMask, const FRichCurve& InPlainsNoiseStrength, const FLinearColor& InPlainsColorLow, const FLinearColor& InRiverColor, const FLinearColor& InBeachColor, const FLinearColor& InMountainsColorHigh, const FLinearColor& InMountainsColorLowLow, const FLinearColor& InMountainsColorLowHigh, const FLinearColor& InPlainsColorHigh, const FLinearColor& InRingOuterColor)
            : Scale(InScale)
            , PlainsNoiseHeight(InPlainsNoiseHeight)
            , RingEdgesHardness(InRingEdgesHardness)
            , Width_in_Degrees(InWidth_in_Degrees)
            , RiverDepth(InRiverDepth)
            , Thickness(InThickness)
            , BaseHeight(InBaseHeight)
            , BaseNoiseHeight(InBaseNoiseHeight)
            , BaseNoiseFrquency(InBaseNoiseFrquency)
            , MountainsNoiseHeight(InMountainsNoiseHeight)
            , Radius(InRadius)
            , RiverWidth(InRiverWidth)
            , PlainsNoiseFrequency(InPlainsNoiseFrequency)
            , MountainsNoiseFrequency(InMountainsNoiseFrequency)
            , RingShape(InRingShape)
            , MoutainsMask(InMoutainsMask)
            , RiverMask(InRiverMask)
            , PlainsNoiseStrength(InPlainsNoiseStrength)
            , PlainsColorLow(InPlainsColorLow)
            , RiverColor(InRiverColor)
            , BeachColor(InBeachColor)
            , MountainsColorHigh(InMountainsColorHigh)
            , MountainsColorLowLow(InMountainsColorLowLow)
            , MountainsColorLowHigh(InMountainsColorLowHigh)
            , PlainsColorHigh(InPlainsColorHigh)
            , RingOuterColor(InRingOuterColor)
        {
        }

        void Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            FVoxelCache Cache;

            {
            }

            Function0_Init(InitStruct);

            {
                // MountainsNoiseFrequency = 0.2
                ConstantsCache.Variable_52 = MountainsNoiseFrequency;

                // PlainsNoiseHeight = 250.0
                ConstantsCache.Variable_58 = PlainsNoiseHeight;

                // RingEdgesHardness = 10.0
                ConstantsCache.Variable_22 = RingEdgesHardness;

                // PI.3.141593
                ConstantsCache.Variable_25 = 3.141593;

                // Width in Degrees = 50.0
                ConstantsCache.Variable_31 = Width_in_Degrees;

                // RiverDepth = 100.0
                ConstantsCache.Variable_66 = RiverDepth;

                // Thickness = 500.0
                ConstantsCache.Variable_96 = Thickness;

                // BaseHeight = 1000.0
                ConstantsCache.Variable_40 = BaseHeight;

                // BaseNoiseHeight = 250.0
                ConstantsCache.Variable_43 = BaseNoiseHeight;

                // BaseNoiseFrquency = 0.005
                ConstantsCache.Variable_46 = BaseNoiseFrquency;

                // MountainsNoiseHeight = 500.0
                ConstantsCache.Variable_49 = MountainsNoiseHeight;

                // Radius = 7000.0
                ConstantsCache.Variable_5 = Radius;

                // RiverWidth = 1.0
                ConstantsCache.Variable_95 = RiverWidth;

                // PlainsNoiseFrequency = 0.2
                ConstantsCache.Variable_61 = PlainsNoiseFrequency;

                // PI.3.141593
                ConstantsCache.Variable_98 = 3.141593;

                // PI.3.141593
                ConstantsCache.Variable_67 = 3.141593;

                // Scale = 10.0
                ConstantsCache.Variable_90 = Scale;

                // *
                ConstantsCache.Variable_91 = ConstantsCache.Variable_5 * ConstantsCache.Variable_90;

                // /
                ConstantsCache.Variable_37 = ConstantsCache.Variable_31 / float(360.0f);

                // *
                ConstantsCache.Variable_97 = ConstantsCache.Variable_96 * ConstantsCache.Variable_90;

                // +
                ConstantsCache.Variable_6 = ConstantsCache.Variable_91 + ConstantsCache.Variable_97;

                // /
                ConstantsCache.Variable_92 = ConstantsCache.Variable_91 / ConstantsCache.Variable_90;

                // -
                ConstantsCache.Variable_36 = float(0.5f) - ConstantsCache.Variable_37;

            }
        }
        void ComputeX(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_X_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXY(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XY_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXYZ(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XYZ_Compute(GraphOutputs, Cache, Context);
        }
        void Get(const FVoxelContext&Context, float& Value, float& Cache2DUsage) const
        {
            FVoxelGraphOutputs GraphOutputs{Value, Cache2DUsage};
            Function0_Compute(GraphOutputs, Context);
        }

    private:
        FVoxelConstantsCache ConstantsCache;
        FastNoise _2D_Simplex_Noise_8756_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15569_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15570_Noise;
        FastNoise _2D_Perlin_Noise_7435_Noise;
        FastNoise _2D_Simplex_Noise_8757_Noise;

        const float& Scale;
        const float& PlainsNoiseHeight;
        const float& RingEdgesHardness;
        const float& Width_in_Degrees;
        const float& RiverDepth;
        const float& Thickness;
        const float& BaseHeight;
        const float& BaseNoiseHeight;
        const float& BaseNoiseFrquency;
        const float& MountainsNoiseHeight;
        const float& Radius;
        const float& RiverWidth;
        const float& PlainsNoiseFrequency;
        const float& MountainsNoiseFrequency;
        const FRichCurve& RingShape;
        const FRichCurve& MoutainsMask;
        const FRichCurve& RiverMask;
        const FRichCurve& PlainsNoiseStrength;
        const FLinearColor& PlainsColorLow;
        const FLinearColor& RiverColor;
        const FLinearColor& BeachColor;
        const FLinearColor& MountainsColorHigh;
        const FLinearColor& MountainsColorLowLow;
        const FLinearColor& MountainsColorLowHigh;
        const FLinearColor& PlainsColorHigh;
        const FLinearColor& RingOuterColor;

        ///////////////////////////////////////////////////////////////////////
        //////////////////////////// Init functions ///////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15569_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15569_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15569_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15569_Noise.SetFractalOctaves(5);
            _2D_Simplex_Noise_Fractal_15569_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15569_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15569_Noise.SetFractalType(FastNoise::FractalType::FBM);

            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15570_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15570_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15570_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15570_Noise.SetFractalOctaves(8);
            _2D_Simplex_Noise_Fractal_15570_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15570_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15570_Noise.SetFractalType(FastNoise::FractalType::FBM);

            // Init of 2D Perlin Noise
            _2D_Perlin_Noise_7435_Noise.SetSeed(Seed(1338));
            _2D_Perlin_Noise_7435_Noise.SetFrequency(0.1);
            _2D_Perlin_Noise_7435_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8757_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_8757_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_8757_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8756_Noise.SetSeed(Seed(1000));
            _2D_Simplex_Noise_8756_Noise.SetFrequency(0.001);
            _2D_Simplex_Noise_8756_Noise.SetInterp(FastNoise::Interp::Quintic);

        }

        ///////////////////////////////////////////////////////////////////////
        ////////////////////////// Compute functions //////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_X_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // X
            Cache.Variable_0 = Context.X;

            // X
            Cache.Variable_24 = Context.X;

        }

        void Function0_XY_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // Y
            Cache.Variable_1 = Context.Y;

            // Y
            Cache.Variable_29 = Context.Y;

            // ATAN2
            Cache.Variable_23 = FVoxelNodeFunctions::Atan2(Cache.Variable_29, Cache.Variable_24);

            // /
            Cache.Variable_26 = Cache.Variable_23 / ConstantsCache.Variable_25;

            // *
            Cache.Variable_28 = ConstantsCache.Variable_92 * Cache.Variable_26;

            // *
            Cache.Variable_45 = Cache.Variable_28 * ConstantsCache.Variable_46;

            // *
            Cache.Variable_51 = Cache.Variable_28 * ConstantsCache.Variable_52;

            // *
            Cache.Variable_60 = Cache.Variable_28 * ConstantsCache.Variable_61;

            // 2D Simplex Noise
            Cache.Variable_79 = _2D_Simplex_Noise_8756_Noise.GetSimplex(Cache.Variable_28, Cache.Variable_28);

            // *
            Cache.Variable_76 = Cache.Variable_79 * float(0.1f);

        }

        void Function0_XYZ_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // Z
            float Variable_12; // Z output 0
            Variable_12 = Context.Z;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Cache.Variable_0, Cache.Variable_1, Variable_2);

            // +
            float Variable_30; // + output 0
            Variable_30 = Variable_3 + float(0.001f);

            // /
            float Variable_13; // / output 0
            Variable_13 = Variable_12 / Variable_30;

            // ACOS
            float Variable_14; // ACOS output 0
            Variable_14 = FVoxelNodeFunctions::Acos(Variable_13);

            // /
            float Variable_10; // / output 0
            Variable_10 = Variable_14 / ConstantsCache.Variable_98;

            // 1 - X
            float Variable_11; // 1 - X output 0
            Variable_11 = 1 - Variable_10;

            // Min (float)
            float Variable_9; // Min (float) output 0
            Variable_9 = FVoxelNodeFunctions::Min<float>(Variable_10, Variable_11);

            // -
            float Variable_15; // - output 0
            Variable_15 = Variable_9 - ConstantsCache.Variable_36;

            // /
            float Variable_35; // / output 0
            Variable_35 = Variable_15 / ConstantsCache.Variable_37;

            // 1 - X
            float Variable_34; // 1 - X output 0
            Variable_34 = 1 - Variable_35;

            // RingCurve
            float Variable_38; // RingCurve output 0
            Variable_38 = RingShape.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_86; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_86 = FMath::Clamp<float>(Variable_38, 0.000000, 1.000000);

            // *
            float Variable_39; // * output 0
            Variable_39 = Variable_86 * ConstantsCache.Variable_40;

            // *
            float Variable_27; // * output 0
            Variable_27 = ConstantsCache.Variable_92 * Variable_10;

            // *
            float Variable_44; // * output 0
            Variable_44 = Variable_27 * ConstantsCache.Variable_46;

            // 2D Simplex Noise Fractal
            float Variable_41; // 2D Simplex Noise Fractal output 0
            Variable_41 = _2D_Simplex_Noise_Fractal_15569_Noise.GetSimplexFractal(Variable_44, Cache.Variable_45);

            // *
            float Variable_42; // * output 0
            Variable_42 = Variable_41 * ConstantsCache.Variable_43;

            // *
            float Variable_50; // * output 0
            Variable_50 = Variable_27 * ConstantsCache.Variable_52;

            // 2D Simplex Noise Fractal
            float Variable_47; // 2D Simplex Noise Fractal output 0
            Variable_47 = _2D_Simplex_Noise_Fractal_15570_Noise.GetSimplexFractal(Variable_50, Cache.Variable_51);

            // MountainsCurve
            float Variable_53; // MountainsCurve output 0
            Variable_53 = MoutainsMask.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_87; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_87 = FMath::Clamp<float>(Variable_53, 0.000000, 1.000000);

            // *
            float Variable_48; // * output 0
            Variable_48 = Variable_47 * ConstantsCache.Variable_49 * Variable_87;

            // 2D Perlin Noise
            float Variable_54; // 2D Perlin Noise output 0
            Variable_54 = _2D_Perlin_Noise_7435_Noise.GetPerlin(Variable_50, Cache.Variable_51);

            // *
            float Variable_55; // * output 0
            Variable_55 = ConstantsCache.Variable_49 * Variable_87 * Variable_54 * float(0.1f);

            // *
            float Variable_59; // * output 0
            Variable_59 = Variable_27 * ConstantsCache.Variable_61;

            // 2D Simplex Noise
            float Variable_63; // 2D Simplex Noise output 0
            Variable_63 = _2D_Simplex_Noise_8757_Noise.GetSimplex(Variable_59, Cache.Variable_60);

            // Z
            float Variable_72; // Z output 0
            Variable_72 = Context.Z;

            // /
            float Variable_73; // / output 0
            Variable_73 = Variable_72 / Variable_30;

            // +
            float Variable_75; // + output 0
            Variable_75 = Variable_73 + Cache.Variable_76;

            // ACOS
            float Variable_74; // ACOS output 0
            Variable_74 = FVoxelNodeFunctions::Acos(Variable_75);

            // /
            float Variable_71; // / output 0
            Variable_71 = Variable_74 / ConstantsCache.Variable_67;

            // 1 - X
            float Variable_69; // 1 - X output 0
            Variable_69 = 1 - Variable_71;

            // Min (float)
            float Variable_68; // Min (float) output 0
            Variable_68 = FVoxelNodeFunctions::Min<float>(Variable_71, Variable_69);

            // /
            float Variable_70; // / output 0
            Variable_70 = Variable_68 / float(0.5f);

            // 1 - X
            float Variable_77; // 1 - X output 0
            Variable_77 = 1 - Variable_70;

            // *
            float Variable_78; // * output 0
            Variable_78 = Variable_77 * float(20.0f);

            // /
            float Variable_94; // / output 0
            Variable_94 = Variable_78 / ConstantsCache.Variable_95;

            // RiverCurve
            float Variable_64; // RiverCurve output 0
            Variable_64 = RiverMask.Eval(Variable_94);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_89; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_89 = FMath::Clamp<float>(Variable_64, -1.000000, 1.000000);

            // Min (float)
            float Variable_81; // Min (float) output 0
            Variable_81 = FVoxelNodeFunctions::Min<float>(Variable_89, float(0.0f));

            // *
            float Variable_82; // * output 0
            Variable_82 = Variable_81 * float(-1.0f);

            // *
            float Variable_83; // * output 0
            Variable_83 = Variable_63 * Variable_82;

            // 1 - X
            float Variable_84; // 1 - X output 0
            Variable_84 = 1 - Variable_82;

            // -
            float Variable_85; // - output 0
            Variable_85 = Variable_83 - Variable_84;

            // 1 - X
            float Variable_56; // 1 - X output 0
            Variable_56 = 1 - Variable_87;

            // PlainsNoiseStrengthCurve
            float Variable_62; // PlainsNoiseStrengthCurve output 0
            Variable_62 = PlainsNoiseStrength.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_88; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_88 = FMath::Clamp<float>(Variable_62, 0.000000, 1.000000);

            // *
            float Variable_57; // * output 0
            Variable_57 = Variable_85 * ConstantsCache.Variable_58 * Variable_56 * Variable_88;

            // Max (float)
            float Variable_80; // Max (float) output 0
            Variable_80 = FVoxelNodeFunctions::Max<float>(Variable_89, float(0.0f));

            // *
            float Variable_65; // * output 0
            Variable_65 = Variable_80 * float(-1.0f) * ConstantsCache.Variable_66;

            // +
            float Variable_33; // + output 0
            Variable_33 = Variable_39 + Variable_42 + Variable_48 + Variable_55 + Variable_57 + Variable_65;

            // *
            float Variable_93; // * output 0
            Variable_93 = Variable_33 * ConstantsCache.Variable_90;

            // -
            float Variable_32; // - output 0
            Variable_32 = ConstantsCache.Variable_91 - Variable_93;

            // -
            float Variable_4; // - output 0
            Variable_4 = Variable_32 - Variable_30;

            // -
            float Variable_7; // - output 0
            Variable_7 = Variable_30 - ConstantsCache.Variable_6;

            // Max (float)
            float Variable_8; // Max (float) output 0
            Variable_8 = FVoxelNodeFunctions::Max<float>(Variable_4, Variable_7);

            // -
            float Variable_19; // - output 0
            Variable_19 = Variable_8 - float(1.0f);

            // Max (float)
            float Variable_18; // Max (float) output 0
            Variable_18 = FVoxelNodeFunctions::Max<float>(Variable_35, float(0.0f));

            // *
            float Variable_20; // * output 0
            Variable_20 = Variable_18 * ConstantsCache.Variable_22;

            // Min (float)
            float Variable_21; // Min (float) output 0
            Variable_21 = FVoxelNodeFunctions::Min<float>(Variable_20, float(1.0f));

            // *
            float Variable_16; // * output 0
            Variable_16 = Variable_19 * Variable_21;

            // +
            float Variable_17; // + output 0
            Variable_17 = Variable_16 + float(1.0f);

            GraphOutputs.Value = Variable_17;
        }

        void Function0_Compute(FVoxelGraphOutputs& GraphOutputs, const FVoxelContext& Context) const
        {
            // Z
            float Variable_12; // Z output 0
            Variable_12 = Context.Z;

            // X
            float Variable_0; // X output 0
            Variable_0 = Context.X;

            // Y
            float Variable_1; // Y output 0
            Variable_1 = Context.Y;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Variable_0, Variable_1, Variable_2);

            // +
            float Variable_30; // + output 0
            Variable_30 = Variable_3 + float(0.001f);

            // /
            float Variable_13; // / output 0
            Variable_13 = Variable_12 / Variable_30;

            // ACOS
            float Variable_14; // ACOS output 0
            Variable_14 = FVoxelNodeFunctions::Acos(Variable_13);

            // /
            float Variable_10; // / output 0
            Variable_10 = Variable_14 / ConstantsCache.Variable_98;

            // 1 - X
            float Variable_11; // 1 - X output 0
            Variable_11 = 1 - Variable_10;

            // Min (float)
            float Variable_9; // Min (float) output 0
            Variable_9 = FVoxelNodeFunctions::Min<float>(Variable_10, Variable_11);

            // -
            float Variable_15; // - output 0
            Variable_15 = Variable_9 - ConstantsCache.Variable_36;

            // /
            float Variable_35; // / output 0
            Variable_35 = Variable_15 / ConstantsCache.Variable_37;

            // 1 - X
            float Variable_34; // 1 - X output 0
            Variable_34 = 1 - Variable_35;

            // RingCurve
            float Variable_38; // RingCurve output 0
            Variable_38 = RingShape.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_86; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_86 = FMath::Clamp<float>(Variable_38, 0.000000, 1.000000);

            // *
            float Variable_39; // * output 0
            Variable_39 = Variable_86 * ConstantsCache.Variable_40;

            // *
            float Variable_27; // * output 0
            Variable_27 = ConstantsCache.Variable_92 * Variable_10;

            // *
            float Variable_44; // * output 0
            Variable_44 = Variable_27 * ConstantsCache.Variable_46;

            // Y
            float Variable_29; // Y output 0
            Variable_29 = Context.Y;

            // X
            float Variable_24; // X output 0
            Variable_24 = Context.X;

            // ATAN2
            float Variable_23; // ATAN2 output 0
            Variable_23 = FVoxelNodeFunctions::Atan2(Variable_29, Variable_24);

            // /
            float Variable_26; // / output 0
            Variable_26 = Variable_23 / ConstantsCache.Variable_25;

            // *
            float Variable_28; // * output 0
            Variable_28 = ConstantsCache.Variable_92 * Variable_26;

            // *
            float Variable_45; // * output 0
            Variable_45 = Variable_28 * ConstantsCache.Variable_46;

            // 2D Simplex Noise Fractal
            float Variable_41; // 2D Simplex Noise Fractal output 0
            Variable_41 = _2D_Simplex_Noise_Fractal_15569_Noise.GetSimplexFractal(Variable_44, Variable_45);

            // *
            float Variable_42; // * output 0
            Variable_42 = Variable_41 * ConstantsCache.Variable_43;

            // *
            float Variable_50; // * output 0
            Variable_50 = Variable_27 * ConstantsCache.Variable_52;

            // *
            float Variable_51; // * output 0
            Variable_51 = Variable_28 * ConstantsCache.Variable_52;

            // 2D Simplex Noise Fractal
            float Variable_47; // 2D Simplex Noise Fractal output 0
            Variable_47 = _2D_Simplex_Noise_Fractal_15570_Noise.GetSimplexFractal(Variable_50, Variable_51);

            // MountainsCurve
            float Variable_53; // MountainsCurve output 0
            Variable_53 = MoutainsMask.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_87; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_87 = FMath::Clamp<float>(Variable_53, 0.000000, 1.000000);

            // *
            float Variable_48; // * output 0
            Variable_48 = Variable_47 * ConstantsCache.Variable_49 * Variable_87;

            // 2D Perlin Noise
            float Variable_54; // 2D Perlin Noise output 0
            Variable_54 = _2D_Perlin_Noise_7435_Noise.GetPerlin(Variable_50, Variable_51);

            // *
            float Variable_55; // * output 0
            Variable_55 = ConstantsCache.Variable_49 * Variable_87 * Variable_54 * float(0.1f);

            // *
            float Variable_59; // * output 0
            Variable_59 = Variable_27 * ConstantsCache.Variable_61;

            // *
            float Variable_60; // * output 0
            Variable_60 = Variable_28 * ConstantsCache.Variable_61;

            // 2D Simplex Noise
            float Variable_63; // 2D Simplex Noise output 0
            Variable_63 = _2D_Simplex_Noise_8757_Noise.GetSimplex(Variable_59, Variable_60);

            // Z
            float Variable_72; // Z output 0
            Variable_72 = Context.Z;

            // /
            float Variable_73; // / output 0
            Variable_73 = Variable_72 / Variable_30;

            // 2D Simplex Noise
            float Variable_79; // 2D Simplex Noise output 0
            Variable_79 = _2D_Simplex_Noise_8756_Noise.GetSimplex(Variable_28, Variable_28);

            // *
            float Variable_76; // * output 0
            Variable_76 = Variable_79 * float(0.1f);

            // +
            float Variable_75; // + output 0
            Variable_75 = Variable_73 + Variable_76;

            // ACOS
            float Variable_74; // ACOS output 0
            Variable_74 = FVoxelNodeFunctions::Acos(Variable_75);

            // /
            float Variable_71; // / output 0
            Variable_71 = Variable_74 / ConstantsCache.Variable_67;

            // 1 - X
            float Variable_69; // 1 - X output 0
            Variable_69 = 1 - Variable_71;

            // Min (float)
            float Variable_68; // Min (float) output 0
            Variable_68 = FVoxelNodeFunctions::Min<float>(Variable_71, Variable_69);

            // /
            float Variable_70; // / output 0
            Variable_70 = Variable_68 / float(0.5f);

            // 1 - X
            float Variable_77; // 1 - X output 0
            Variable_77 = 1 - Variable_70;

            // *
            float Variable_78; // * output 0
            Variable_78 = Variable_77 * float(20.0f);

            // /
            float Variable_94; // / output 0
            Variable_94 = Variable_78 / ConstantsCache.Variable_95;

            // RiverCurve
            float Variable_64; // RiverCurve output 0
            Variable_64 = RiverMask.Eval(Variable_94);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_89; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_89 = FMath::Clamp<float>(Variable_64, -1.000000, 1.000000);

            // Min (float)
            float Variable_81; // Min (float) output 0
            Variable_81 = FVoxelNodeFunctions::Min<float>(Variable_89, float(0.0f));

            // *
            float Variable_82; // * output 0
            Variable_82 = Variable_81 * float(-1.0f);

            // *
            float Variable_83; // * output 0
            Variable_83 = Variable_63 * Variable_82;

            // 1 - X
            float Variable_84; // 1 - X output 0
            Variable_84 = 1 - Variable_82;

            // -
            float Variable_85; // - output 0
            Variable_85 = Variable_83 - Variable_84;

            // 1 - X
            float Variable_56; // 1 - X output 0
            Variable_56 = 1 - Variable_87;

            // PlainsNoiseStrengthCurve
            float Variable_62; // PlainsNoiseStrengthCurve output 0
            Variable_62 = PlainsNoiseStrength.Eval(Variable_34);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_88; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_88 = FMath::Clamp<float>(Variable_62, 0.000000, 1.000000);

            // *
            float Variable_57; // * output 0
            Variable_57 = Variable_85 * ConstantsCache.Variable_58 * Variable_56 * Variable_88;

            // Max (float)
            float Variable_80; // Max (float) output 0
            Variable_80 = FVoxelNodeFunctions::Max<float>(Variable_89, float(0.0f));

            // *
            float Variable_65; // * output 0
            Variable_65 = Variable_80 * float(-1.0f) * ConstantsCache.Variable_66;

            // +
            float Variable_33; // + output 0
            Variable_33 = Variable_39 + Variable_42 + Variable_48 + Variable_55 + Variable_57 + Variable_65;

            // *
            float Variable_93; // * output 0
            Variable_93 = Variable_33 * ConstantsCache.Variable_90;

            // -
            float Variable_32; // - output 0
            Variable_32 = ConstantsCache.Variable_91 - Variable_93;

            // -
            float Variable_4; // - output 0
            Variable_4 = Variable_32 - Variable_30;

            // -
            float Variable_7; // - output 0
            Variable_7 = Variable_30 - ConstantsCache.Variable_6;

            // Max (float)
            float Variable_8; // Max (float) output 0
            Variable_8 = FVoxelNodeFunctions::Max<float>(Variable_4, Variable_7);

            // -
            float Variable_19; // - output 0
            Variable_19 = Variable_8 - float(1.0f);

            // Max (float)
            float Variable_18; // Max (float) output 0
            Variable_18 = FVoxelNodeFunctions::Max<float>(Variable_35, float(0.0f));

            // *
            float Variable_20; // * output 0
            Variable_20 = Variable_18 * ConstantsCache.Variable_22;

            // Min (float)
            float Variable_21; // Min (float) output 0
            Variable_21 = FVoxelNodeFunctions::Min<float>(Variable_20, float(1.0f));

            // *
            float Variable_16; // * output 0
            Variable_16 = Variable_19 * Variable_21;

            // +
            float Variable_17; // + output 0
            Variable_17 = Variable_16 + float(1.0f);

            GraphOutputs.Value = Variable_17;
        }

    };
    struct FLocalComputeStruct_LocalMaterialCache2DUsage_LOD0
    {
        struct FVoxelGraphOutputs
        {
            FVoxelMaterial& Material;
            float& Cache2DUsage;
        };
        struct FVoxelConstantsCache
        {
            float Variable_61; // PlainsColorLow output 0
            float Variable_62; // PlainsColorLow output 1
            float Variable_63; // PlainsColorLow output 2
            float Variable_64; // PlainsColorLow output 3
            float Variable_15; // RingEdgesHardness = 10.0 output 0
            float Variable_18; // PI.3.141593 output 0
            float Variable_25; // Width in Degrees = 50.0 output 0
            float Variable_69; // RiverColor output 0
            float Variable_70; // RiverColor output 1
            float Variable_71; // RiverColor output 2
            float Variable_72; // RiverColor output 3
            float Variable_92; // BeachColor output 0
            float Variable_93; // BeachColor output 1
            float Variable_94; // BeachColor output 2
            float Variable_95; // BeachColor output 3
            float Variable_33; // MountainsNoiseFrequency = 0.2 output 0
            float Variable_36; // MountainsColorHigh output 0
            float Variable_37; // MountainsColorHigh output 1
            float Variable_38; // MountainsColorHigh output 2
            float Variable_39; // MountainsColorHigh output 3
            float Variable_40; // MountainsColorLowLow output 0
            float Variable_41; // MountainsColorLowLow output 1
            float Variable_42; // MountainsColorLowLow output 2
            float Variable_43; // MountainsColorLowLow output 3
            float Variable_46; // MountainsColorLowHigh output 0
            float Variable_47; // MountainsColorLowHigh output 1
            float Variable_48; // MountainsColorLowHigh output 2
            float Variable_49; // MountainsColorLowHigh output 3
            float Variable_52; // PlainsNoiseFrequency = 0.2 output 0
            float Variable_54; // PlainsColorHigh output 0
            float Variable_55; // PlainsColorHigh output 1
            float Variable_56; // PlainsColorHigh output 2
            float Variable_57; // PlainsColorHigh output 3
            float Variable_4; // Radius = 7000.0 output 0
            float Variable_68; // PI.3.141593 output 0
            float Variable_104; // RiverWidth = 1.0 output 0
            float Variable_100; // Scale = 10.0 output 0
            float Variable_108; // Thickness = 500.0 output 0
            float Variable_110; // PI.3.141593 output 0
            float Variable_112; // RingOuterColor output 0
            float Variable_113; // RingOuterColor output 1
            float Variable_114; // RingOuterColor output 2
            float Variable_115; // RingOuterColor output 3
            float Variable_109; // * output 0
            float Variable_29; // / output 0
            float Variable_101; // * output 0
            float Variable_102; // / output 0
            float Variable_28; // - output 0
            float Variable_107; // + output 0
        };
        struct FVoxelCache
        {
            float Variable_0; // X output 0
            float Variable_17; // X output 0
            float Variable_1; // Y output 0
            float Variable_23; // Y output 0
            float Variable_16; // ATAN2 output 0
            float Variable_19; // / output 0
            float Variable_22; // * output 0
            float Variable_51; // * output 0
            float Variable_85; // 2D Simplex Noise output 0
            float Variable_82; // * output 0
            float Variable_32; // * output 0
        };

        FLocalComputeStruct_LocalMaterialCache2DUsage_LOD0(const float& InScale, const float& InPlainsNoiseHeight, const float& InRingEdgesHardness, const float& InWidth_in_Degrees, const float& InRiverDepth, const float& InThickness, const float& InBaseHeight, const float& InBaseNoiseHeight, const float& InBaseNoiseFrquency, const float& InMountainsNoiseHeight, const float& InRadius, const float& InRiverWidth, const float& InPlainsNoiseFrequency, const float& InMountainsNoiseFrequency, const FRichCurve& InRingShape, const FRichCurve& InMoutainsMask, const FRichCurve& InRiverMask, const FRichCurve& InPlainsNoiseStrength, const FLinearColor& InPlainsColorLow, const FLinearColor& InRiverColor, const FLinearColor& InBeachColor, const FLinearColor& InMountainsColorHigh, const FLinearColor& InMountainsColorLowLow, const FLinearColor& InMountainsColorLowHigh, const FLinearColor& InPlainsColorHigh, const FLinearColor& InRingOuterColor)
            : Scale(InScale)
            , PlainsNoiseHeight(InPlainsNoiseHeight)
            , RingEdgesHardness(InRingEdgesHardness)
            , Width_in_Degrees(InWidth_in_Degrees)
            , RiverDepth(InRiverDepth)
            , Thickness(InThickness)
            , BaseHeight(InBaseHeight)
            , BaseNoiseHeight(InBaseNoiseHeight)
            , BaseNoiseFrquency(InBaseNoiseFrquency)
            , MountainsNoiseHeight(InMountainsNoiseHeight)
            , Radius(InRadius)
            , RiverWidth(InRiverWidth)
            , PlainsNoiseFrequency(InPlainsNoiseFrequency)
            , MountainsNoiseFrequency(InMountainsNoiseFrequency)
            , RingShape(InRingShape)
            , MoutainsMask(InMoutainsMask)
            , RiverMask(InRiverMask)
            , PlainsNoiseStrength(InPlainsNoiseStrength)
            , PlainsColorLow(InPlainsColorLow)
            , RiverColor(InRiverColor)
            , BeachColor(InBeachColor)
            , MountainsColorHigh(InMountainsColorHigh)
            , MountainsColorLowLow(InMountainsColorLowLow)
            , MountainsColorLowHigh(InMountainsColorLowHigh)
            , PlainsColorHigh(InPlainsColorHigh)
            , RingOuterColor(InRingOuterColor)
        {
        }

        void Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            FVoxelCache Cache;

            {
            }

            Function0_Init(InitStruct);

            {
                // PlainsColorLow
                ConstantsCache.Variable_61 = PlainsColorLow.R;
                ConstantsCache.Variable_62 = PlainsColorLow.G;
                ConstantsCache.Variable_63 = PlainsColorLow.B;
                ConstantsCache.Variable_64 = PlainsColorLow.A;

                // RingEdgesHardness = 10.0
                ConstantsCache.Variable_15 = RingEdgesHardness;

                // PI.3.141593
                ConstantsCache.Variable_18 = 3.141593;

                // Width in Degrees = 50.0
                ConstantsCache.Variable_25 = Width_in_Degrees;

                // RiverColor
                ConstantsCache.Variable_69 = RiverColor.R;
                ConstantsCache.Variable_70 = RiverColor.G;
                ConstantsCache.Variable_71 = RiverColor.B;
                ConstantsCache.Variable_72 = RiverColor.A;

                // BeachColor
                ConstantsCache.Variable_92 = BeachColor.R;
                ConstantsCache.Variable_93 = BeachColor.G;
                ConstantsCache.Variable_94 = BeachColor.B;
                ConstantsCache.Variable_95 = BeachColor.A;

                // MountainsNoiseFrequency = 0.2
                ConstantsCache.Variable_33 = MountainsNoiseFrequency;

                // MountainsColorHigh
                ConstantsCache.Variable_36 = MountainsColorHigh.R;
                ConstantsCache.Variable_37 = MountainsColorHigh.G;
                ConstantsCache.Variable_38 = MountainsColorHigh.B;
                ConstantsCache.Variable_39 = MountainsColorHigh.A;

                // MountainsColorLowLow
                ConstantsCache.Variable_40 = MountainsColorLowLow.R;
                ConstantsCache.Variable_41 = MountainsColorLowLow.G;
                ConstantsCache.Variable_42 = MountainsColorLowLow.B;
                ConstantsCache.Variable_43 = MountainsColorLowLow.A;

                // MountainsColorLowHigh
                ConstantsCache.Variable_46 = MountainsColorLowHigh.R;
                ConstantsCache.Variable_47 = MountainsColorLowHigh.G;
                ConstantsCache.Variable_48 = MountainsColorLowHigh.B;
                ConstantsCache.Variable_49 = MountainsColorLowHigh.A;

                // PlainsNoiseFrequency = 0.2
                ConstantsCache.Variable_52 = PlainsNoiseFrequency;

                // PlainsColorHigh
                ConstantsCache.Variable_54 = PlainsColorHigh.R;
                ConstantsCache.Variable_55 = PlainsColorHigh.G;
                ConstantsCache.Variable_56 = PlainsColorHigh.B;
                ConstantsCache.Variable_57 = PlainsColorHigh.A;

                // Radius = 7000.0
                ConstantsCache.Variable_4 = Radius;

                // PI.3.141593
                ConstantsCache.Variable_68 = 3.141593;

                // RiverWidth = 1.0
                ConstantsCache.Variable_104 = RiverWidth;

                // Scale = 10.0
                ConstantsCache.Variable_100 = Scale;

                // Thickness = 500.0
                ConstantsCache.Variable_108 = Thickness;

                // PI.3.141593
                ConstantsCache.Variable_110 = 3.141593;

                // RingOuterColor
                ConstantsCache.Variable_112 = RingOuterColor.R;
                ConstantsCache.Variable_113 = RingOuterColor.G;
                ConstantsCache.Variable_114 = RingOuterColor.B;
                ConstantsCache.Variable_115 = RingOuterColor.A;

                // *
                ConstantsCache.Variable_109 = ConstantsCache.Variable_108 * ConstantsCache.Variable_100;

                // /
                ConstantsCache.Variable_29 = ConstantsCache.Variable_25 / float(360.0f);

                // *
                ConstantsCache.Variable_101 = ConstantsCache.Variable_4 * ConstantsCache.Variable_100;

                // /
                ConstantsCache.Variable_102 = ConstantsCache.Variable_101 / ConstantsCache.Variable_100;

                // -
                ConstantsCache.Variable_28 = float(0.5f) - ConstantsCache.Variable_29;

                // +
                ConstantsCache.Variable_107 = ConstantsCache.Variable_101 + ConstantsCache.Variable_109 + float(-5.0f);

            }
        }
        void ComputeX(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_X_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXY(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XY_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXYZ(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XYZ_Compute(GraphOutputs, Cache, Context);
        }
        void Get(const FVoxelContext&Context, FVoxelMaterial& Material, float& Cache2DUsage) const
        {
            FVoxelGraphOutputs GraphOutputs{Material, Cache2DUsage};
            Function0_Compute(GraphOutputs, Context);
        }

    private:
        FVoxelConstantsCache ConstantsCache;
        FastNoise _2D_Simplex_Noise_8758_Noise;
        FastNoise _2D_Simplex_Noise_8759_Noise;
        FastNoise _2D_Perlin_Noise_7436_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15571_Noise;

        const float& Scale;
        const float& PlainsNoiseHeight;
        const float& RingEdgesHardness;
        const float& Width_in_Degrees;
        const float& RiverDepth;
        const float& Thickness;
        const float& BaseHeight;
        const float& BaseNoiseHeight;
        const float& BaseNoiseFrquency;
        const float& MountainsNoiseHeight;
        const float& Radius;
        const float& RiverWidth;
        const float& PlainsNoiseFrequency;
        const float& MountainsNoiseFrequency;
        const FRichCurve& RingShape;
        const FRichCurve& MoutainsMask;
        const FRichCurve& RiverMask;
        const FRichCurve& PlainsNoiseStrength;
        const FLinearColor& PlainsColorLow;
        const FLinearColor& RiverColor;
        const FLinearColor& BeachColor;
        const FLinearColor& MountainsColorHigh;
        const FLinearColor& MountainsColorLowLow;
        const FLinearColor& MountainsColorLowHigh;
        const FLinearColor& PlainsColorHigh;
        const FLinearColor& RingOuterColor;

        ///////////////////////////////////////////////////////////////////////
        //////////////////////////// Init functions ///////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8759_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_8759_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_8759_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8758_Noise.SetSeed(Seed(1000));
            _2D_Simplex_Noise_8758_Noise.SetFrequency(0.001);
            _2D_Simplex_Noise_8758_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Perlin Noise
            _2D_Perlin_Noise_7436_Noise.SetSeed(Seed(1338));
            _2D_Perlin_Noise_7436_Noise.SetFrequency(0.1);
            _2D_Perlin_Noise_7436_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15571_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15571_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15571_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15571_Noise.SetFractalOctaves(8);
            _2D_Simplex_Noise_Fractal_15571_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15571_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15571_Noise.SetFractalType(FastNoise::FractalType::FBM);

        }

        ///////////////////////////////////////////////////////////////////////
        ////////////////////////// Compute functions //////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_X_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // X
            Cache.Variable_0 = Context.X;

            // X
            Cache.Variable_17 = Context.X;

        }

        void Function0_XY_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // Y
            Cache.Variable_1 = Context.Y;

            // Y
            Cache.Variable_23 = Context.Y;

            // ATAN2
            Cache.Variable_16 = FVoxelNodeFunctions::Atan2(Cache.Variable_23, Cache.Variable_17);

            // /
            Cache.Variable_19 = Cache.Variable_16 / ConstantsCache.Variable_18;

            // *
            Cache.Variable_22 = ConstantsCache.Variable_102 * Cache.Variable_19;

            // *
            Cache.Variable_51 = Cache.Variable_22 * ConstantsCache.Variable_52;

            // 2D Simplex Noise
            Cache.Variable_85 = _2D_Simplex_Noise_8758_Noise.GetSimplex(Cache.Variable_22, Cache.Variable_22);

            // *
            Cache.Variable_82 = Cache.Variable_85 * float(0.1f);

            // *
            Cache.Variable_32 = Cache.Variable_22 * ConstantsCache.Variable_33;

        }

        void Function0_XYZ_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // Z
            float Variable_8; // Z output 0
            Variable_8 = Context.Z;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Cache.Variable_0, Cache.Variable_1, Variable_2);

            // +
            float Variable_24; // + output 0
            Variable_24 = Variable_3 + float(0.001f);

            // /
            float Variable_9; // / output 0
            Variable_9 = Variable_8 / Variable_24;

            // ACOS
            float Variable_10; // ACOS output 0
            Variable_10 = FVoxelNodeFunctions::Acos(Variable_9);

            // /
            float Variable_6; // / output 0
            Variable_6 = Variable_10 / ConstantsCache.Variable_110;

            // *
            float Variable_21; // * output 0
            Variable_21 = ConstantsCache.Variable_102 * Variable_6;

            // *
            float Variable_50; // * output 0
            Variable_50 = Variable_21 * ConstantsCache.Variable_52;

            // 2D Simplex Noise
            float Variable_58; // 2D Simplex Noise output 0
            Variable_58 = _2D_Simplex_Noise_8759_Noise.GetSimplex(Variable_50, Cache.Variable_51);

            // Z
            float Variable_77; // Z output 0
            Variable_77 = Context.Z;

            // /
            float Variable_78; // / output 0
            Variable_78 = Variable_77 / Variable_24;

            // +
            float Variable_81; // + output 0
            Variable_81 = Variable_78 + Cache.Variable_82;

            // ACOS
            float Variable_79; // ACOS output 0
            Variable_79 = FVoxelNodeFunctions::Acos(Variable_81);

            // /
            float Variable_76; // / output 0
            Variable_76 = Variable_79 / ConstantsCache.Variable_68;

            // 1 - X
            float Variable_74; // 1 - X output 0
            Variable_74 = 1 - Variable_76;

            // Min (float)
            float Variable_73; // Min (float) output 0
            Variable_73 = FVoxelNodeFunctions::Min<float>(Variable_76, Variable_74);

            // /
            float Variable_75; // / output 0
            Variable_75 = Variable_73 / float(0.5f);

            // 1 - X
            float Variable_83; // 1 - X output 0
            Variable_83 = 1 - Variable_75;

            // *
            float Variable_84; // * output 0
            Variable_84 = Variable_83 * float(20.0f);

            // /
            float Variable_103; // / output 0
            Variable_103 = Variable_84 / ConstantsCache.Variable_104;

            // RiverCurve
            float Variable_67; // RiverCurve output 0
            Variable_67 = RiverMask.Eval(Variable_103);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_99; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_99 = FMath::Clamp<float>(Variable_67, -1.000000, 1.000000);

            // Min (float)
            float Variable_86; // Min (float) output 0
            Variable_86 = FVoxelNodeFunctions::Min<float>(Variable_99, float(0.0f));

            // *
            float Variable_87; // * output 0
            Variable_87 = Variable_86 * float(-1.0f);

            // *
            float Variable_88; // * output 0
            Variable_88 = Variable_58 * Variable_87;

            // 1 - X
            float Variable_89; // 1 - X output 0
            Variable_89 = 1 - Variable_87;

            // -
            float Variable_90; // - output 0
            Variable_90 = Variable_88 - Variable_89;

            // BlendColors.Clamp
            float Variable_53; // BlendColors.Clamp output 0
            Variable_53 = FVoxelNodeFunctions::Clamp(Variable_90, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_128; // BlendColors.Lerp output 0
            Variable_128 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_61, ConstantsCache.Variable_54, Variable_53);

            // *
            float Variable_97; // * output 0
            Variable_97 = Variable_99 * float(10.0f);

            // BlendColors.Clamp
            float Variable_80; // BlendColors.Clamp output 0
            Variable_80 = FVoxelNodeFunctions::Clamp(Variable_97, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_136; // BlendColors.Lerp output 0
            Variable_136 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_92, ConstantsCache.Variable_69, Variable_80);

            // +
            float Variable_91; // + output 0
            Variable_91 = Variable_99 + float(0.3f);

            // BlendColors.Clamp
            float Variable_60; // BlendColors.Clamp output 0
            Variable_60 = FVoxelNodeFunctions::Clamp(Variable_91, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_132; // BlendColors.Lerp output 0
            Variable_132 = FVoxelNodeFunctions::Lerp(Variable_128, Variable_136, Variable_60);

            // *
            float Variable_31; // * output 0
            Variable_31 = Variable_21 * ConstantsCache.Variable_33;

            // 2D Perlin Noise
            float Variable_44; // 2D Perlin Noise output 0
            Variable_44 = _2D_Perlin_Noise_7436_Noise.GetPerlin(Variable_31, Cache.Variable_32);

            // BlendColors.Clamp
            float Variable_35; // BlendColors.Clamp output 0
            Variable_35 = FVoxelNodeFunctions::Clamp(Variable_44, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_120; // BlendColors.Lerp output 0
            Variable_120 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_40, ConstantsCache.Variable_46, Variable_35);

            // 2D Simplex Noise Fractal
            float Variable_30; // 2D Simplex Noise Fractal output 0
            Variable_30 = _2D_Simplex_Noise_Fractal_15571_Noise.GetSimplexFractal(Variable_31, Cache.Variable_32);

            // BlendColors.Clamp
            float Variable_20; // BlendColors.Clamp output 0
            Variable_20 = FVoxelNodeFunctions::Clamp(Variable_30, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_116; // BlendColors.Lerp output 0
            Variable_116 = FVoxelNodeFunctions::Lerp(Variable_120, ConstantsCache.Variable_36, Variable_20);

            // 1 - X
            float Variable_7; // 1 - X output 0
            Variable_7 = 1 - Variable_6;

            // Min (float)
            float Variable_5; // Min (float) output 0
            Variable_5 = FVoxelNodeFunctions::Min<float>(Variable_6, Variable_7);

            // -
            float Variable_11; // - output 0
            Variable_11 = Variable_5 - ConstantsCache.Variable_28;

            // /
            float Variable_27; // / output 0
            Variable_27 = Variable_11 / ConstantsCache.Variable_29;

            // 1 - X
            float Variable_26; // 1 - X output 0
            Variable_26 = 1 - Variable_27;

            // MountainsCurve
            float Variable_34; // MountainsCurve output 0
            Variable_34 = MoutainsMask.Eval(Variable_26);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_98; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_98 = FMath::Clamp<float>(Variable_34, 0.000000, 1.000000);

            // *
            float Variable_59; // * output 0
            Variable_59 = Variable_98 * float(3.0f);

            // Max (float)
            float Variable_65; // Max (float) output 0
            Variable_65 = FVoxelNodeFunctions::Max<float>(Variable_90, float(0.0f));

            // -
            float Variable_66; // - output 0
            Variable_66 = Variable_59 - Variable_65;

            // BlendColors.Clamp
            float Variable_45; // BlendColors.Clamp output 0
            Variable_45 = FVoxelNodeFunctions::Clamp(Variable_66, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_124; // BlendColors.Lerp output 0
            Variable_124 = FVoxelNodeFunctions::Lerp(Variable_132, Variable_116, Variable_45);

            // Max (float)
            float Variable_12; // Max (float) output 0
            Variable_12 = FVoxelNodeFunctions::Max<float>(Variable_27, float(0.0f));

            // *
            float Variable_13; // * output 0
            Variable_13 = Variable_12 * ConstantsCache.Variable_15;

            // Min (float)
            float Variable_14; // Min (float) output 0
            Variable_14 = FVoxelNodeFunctions::Min<float>(Variable_13, float(1.0f));

            // -
            float Variable_111; // - output 0
            Variable_111 = ConstantsCache.Variable_107 - Variable_24;

            // Clamp
            float Variable_105; // Clamp output 0
            Variable_105 = FVoxelNodeFunctions::Clamp(Variable_111, float(0.0f), float(1.0f));

            // Min (float)
            float Variable_106; // Min (float) output 0
            Variable_106 = FVoxelNodeFunctions::Min<float>(Variable_14, Variable_105);

            // BlendColors.Clamp
            float Variable_96; // BlendColors.Clamp output 0
            Variable_96 = FVoxelNodeFunctions::Clamp(Variable_106, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_140; // BlendColors.Lerp output 0
            Variable_140 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_112, Variable_124, Variable_96);

            // BlendColors.Lerp
            float Variable_129; // BlendColors.Lerp output 0
            Variable_129 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_62, ConstantsCache.Variable_55, Variable_53);

            // BlendColors.Lerp
            float Variable_137; // BlendColors.Lerp output 0
            Variable_137 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_93, ConstantsCache.Variable_70, Variable_80);

            // BlendColors.Lerp
            float Variable_133; // BlendColors.Lerp output 0
            Variable_133 = FVoxelNodeFunctions::Lerp(Variable_129, Variable_137, Variable_60);

            // BlendColors.Lerp
            float Variable_121; // BlendColors.Lerp output 0
            Variable_121 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_41, ConstantsCache.Variable_47, Variable_35);

            // BlendColors.Lerp
            float Variable_117; // BlendColors.Lerp output 0
            Variable_117 = FVoxelNodeFunctions::Lerp(Variable_121, ConstantsCache.Variable_37, Variable_20);

            // BlendColors.Lerp
            float Variable_125; // BlendColors.Lerp output 0
            Variable_125 = FVoxelNodeFunctions::Lerp(Variable_133, Variable_117, Variable_45);

            // BlendColors.Lerp
            float Variable_141; // BlendColors.Lerp output 0
            Variable_141 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_113, Variable_125, Variable_96);

            // BlendColors.Lerp
            float Variable_130; // BlendColors.Lerp output 0
            Variable_130 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_63, ConstantsCache.Variable_56, Variable_53);

            // BlendColors.Lerp
            float Variable_138; // BlendColors.Lerp output 0
            Variable_138 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_94, ConstantsCache.Variable_71, Variable_80);

            // BlendColors.Lerp
            float Variable_134; // BlendColors.Lerp output 0
            Variable_134 = FVoxelNodeFunctions::Lerp(Variable_130, Variable_138, Variable_60);

            // BlendColors.Lerp
            float Variable_122; // BlendColors.Lerp output 0
            Variable_122 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_42, ConstantsCache.Variable_48, Variable_35);

            // BlendColors.Lerp
            float Variable_118; // BlendColors.Lerp output 0
            Variable_118 = FVoxelNodeFunctions::Lerp(Variable_122, ConstantsCache.Variable_38, Variable_20);

            // BlendColors.Lerp
            float Variable_126; // BlendColors.Lerp output 0
            Variable_126 = FVoxelNodeFunctions::Lerp(Variable_134, Variable_118, Variable_45);

            // BlendColors.Lerp
            float Variable_142; // BlendColors.Lerp output 0
            Variable_142 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_114, Variable_126, Variable_96);

            // BlendColors.Lerp
            float Variable_131; // BlendColors.Lerp output 0
            Variable_131 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_64, ConstantsCache.Variable_57, Variable_53);

            // BlendColors.Lerp
            float Variable_139; // BlendColors.Lerp output 0
            Variable_139 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_95, ConstantsCache.Variable_72, Variable_80);

            // BlendColors.Lerp
            float Variable_135; // BlendColors.Lerp output 0
            Variable_135 = FVoxelNodeFunctions::Lerp(Variable_131, Variable_139, Variable_60);

            // BlendColors.Lerp
            float Variable_123; // BlendColors.Lerp output 0
            Variable_123 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_43, ConstantsCache.Variable_49, Variable_35);

            // BlendColors.Lerp
            float Variable_119; // BlendColors.Lerp output 0
            Variable_119 = FVoxelNodeFunctions::Lerp(Variable_123, ConstantsCache.Variable_39, Variable_20);

            // BlendColors.Lerp
            float Variable_127; // BlendColors.Lerp output 0
            Variable_127 = FVoxelNodeFunctions::Lerp(Variable_135, Variable_119, Variable_45);

            // BlendColors.Lerp
            float Variable_143; // BlendColors.Lerp output 0
            Variable_143 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_115, Variable_127, Variable_96);

            GraphOutputs.Material.SetColor(FLinearColor(Variable_140, Variable_141, Variable_142, Variable_143));
        }

        void Function0_Compute(FVoxelGraphOutputs& GraphOutputs, const FVoxelContext& Context) const
        {
            // Z
            float Variable_8; // Z output 0
            Variable_8 = Context.Z;

            // X
            float Variable_0; // X output 0
            Variable_0 = Context.X;

            // Y
            float Variable_1; // Y output 0
            Variable_1 = Context.Y;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Variable_0, Variable_1, Variable_2);

            // +
            float Variable_24; // + output 0
            Variable_24 = Variable_3 + float(0.001f);

            // /
            float Variable_9; // / output 0
            Variable_9 = Variable_8 / Variable_24;

            // ACOS
            float Variable_10; // ACOS output 0
            Variable_10 = FVoxelNodeFunctions::Acos(Variable_9);

            // /
            float Variable_6; // / output 0
            Variable_6 = Variable_10 / ConstantsCache.Variable_110;

            // *
            float Variable_21; // * output 0
            Variable_21 = ConstantsCache.Variable_102 * Variable_6;

            // *
            float Variable_50; // * output 0
            Variable_50 = Variable_21 * ConstantsCache.Variable_52;

            // Y
            float Variable_23; // Y output 0
            Variable_23 = Context.Y;

            // X
            float Variable_17; // X output 0
            Variable_17 = Context.X;

            // ATAN2
            float Variable_16; // ATAN2 output 0
            Variable_16 = FVoxelNodeFunctions::Atan2(Variable_23, Variable_17);

            // /
            float Variable_19; // / output 0
            Variable_19 = Variable_16 / ConstantsCache.Variable_18;

            // *
            float Variable_22; // * output 0
            Variable_22 = ConstantsCache.Variable_102 * Variable_19;

            // *
            float Variable_51; // * output 0
            Variable_51 = Variable_22 * ConstantsCache.Variable_52;

            // 2D Simplex Noise
            float Variable_58; // 2D Simplex Noise output 0
            Variable_58 = _2D_Simplex_Noise_8759_Noise.GetSimplex(Variable_50, Variable_51);

            // Z
            float Variable_77; // Z output 0
            Variable_77 = Context.Z;

            // /
            float Variable_78; // / output 0
            Variable_78 = Variable_77 / Variable_24;

            // 2D Simplex Noise
            float Variable_85; // 2D Simplex Noise output 0
            Variable_85 = _2D_Simplex_Noise_8758_Noise.GetSimplex(Variable_22, Variable_22);

            // *
            float Variable_82; // * output 0
            Variable_82 = Variable_85 * float(0.1f);

            // +
            float Variable_81; // + output 0
            Variable_81 = Variable_78 + Variable_82;

            // ACOS
            float Variable_79; // ACOS output 0
            Variable_79 = FVoxelNodeFunctions::Acos(Variable_81);

            // /
            float Variable_76; // / output 0
            Variable_76 = Variable_79 / ConstantsCache.Variable_68;

            // 1 - X
            float Variable_74; // 1 - X output 0
            Variable_74 = 1 - Variable_76;

            // Min (float)
            float Variable_73; // Min (float) output 0
            Variable_73 = FVoxelNodeFunctions::Min<float>(Variable_76, Variable_74);

            // /
            float Variable_75; // / output 0
            Variable_75 = Variable_73 / float(0.5f);

            // 1 - X
            float Variable_83; // 1 - X output 0
            Variable_83 = 1 - Variable_75;

            // *
            float Variable_84; // * output 0
            Variable_84 = Variable_83 * float(20.0f);

            // /
            float Variable_103; // / output 0
            Variable_103 = Variable_84 / ConstantsCache.Variable_104;

            // RiverCurve
            float Variable_67; // RiverCurve output 0
            Variable_67 = RiverMask.Eval(Variable_103);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_99; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_99 = FMath::Clamp<float>(Variable_67, -1.000000, 1.000000);

            // Min (float)
            float Variable_86; // Min (float) output 0
            Variable_86 = FVoxelNodeFunctions::Min<float>(Variable_99, float(0.0f));

            // *
            float Variable_87; // * output 0
            Variable_87 = Variable_86 * float(-1.0f);

            // *
            float Variable_88; // * output 0
            Variable_88 = Variable_58 * Variable_87;

            // 1 - X
            float Variable_89; // 1 - X output 0
            Variable_89 = 1 - Variable_87;

            // -
            float Variable_90; // - output 0
            Variable_90 = Variable_88 - Variable_89;

            // BlendColors.Clamp
            float Variable_53; // BlendColors.Clamp output 0
            Variable_53 = FVoxelNodeFunctions::Clamp(Variable_90, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_128; // BlendColors.Lerp output 0
            Variable_128 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_61, ConstantsCache.Variable_54, Variable_53);

            // *
            float Variable_97; // * output 0
            Variable_97 = Variable_99 * float(10.0f);

            // BlendColors.Clamp
            float Variable_80; // BlendColors.Clamp output 0
            Variable_80 = FVoxelNodeFunctions::Clamp(Variable_97, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_136; // BlendColors.Lerp output 0
            Variable_136 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_92, ConstantsCache.Variable_69, Variable_80);

            // +
            float Variable_91; // + output 0
            Variable_91 = Variable_99 + float(0.3f);

            // BlendColors.Clamp
            float Variable_60; // BlendColors.Clamp output 0
            Variable_60 = FVoxelNodeFunctions::Clamp(Variable_91, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_132; // BlendColors.Lerp output 0
            Variable_132 = FVoxelNodeFunctions::Lerp(Variable_128, Variable_136, Variable_60);

            // *
            float Variable_31; // * output 0
            Variable_31 = Variable_21 * ConstantsCache.Variable_33;

            // *
            float Variable_32; // * output 0
            Variable_32 = Variable_22 * ConstantsCache.Variable_33;

            // 2D Perlin Noise
            float Variable_44; // 2D Perlin Noise output 0
            Variable_44 = _2D_Perlin_Noise_7436_Noise.GetPerlin(Variable_31, Variable_32);

            // BlendColors.Clamp
            float Variable_35; // BlendColors.Clamp output 0
            Variable_35 = FVoxelNodeFunctions::Clamp(Variable_44, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_120; // BlendColors.Lerp output 0
            Variable_120 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_40, ConstantsCache.Variable_46, Variable_35);

            // 2D Simplex Noise Fractal
            float Variable_30; // 2D Simplex Noise Fractal output 0
            Variable_30 = _2D_Simplex_Noise_Fractal_15571_Noise.GetSimplexFractal(Variable_31, Variable_32);

            // BlendColors.Clamp
            float Variable_20; // BlendColors.Clamp output 0
            Variable_20 = FVoxelNodeFunctions::Clamp(Variable_30, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_116; // BlendColors.Lerp output 0
            Variable_116 = FVoxelNodeFunctions::Lerp(Variable_120, ConstantsCache.Variable_36, Variable_20);

            // 1 - X
            float Variable_7; // 1 - X output 0
            Variable_7 = 1 - Variable_6;

            // Min (float)
            float Variable_5; // Min (float) output 0
            Variable_5 = FVoxelNodeFunctions::Min<float>(Variable_6, Variable_7);

            // -
            float Variable_11; // - output 0
            Variable_11 = Variable_5 - ConstantsCache.Variable_28;

            // /
            float Variable_27; // / output 0
            Variable_27 = Variable_11 / ConstantsCache.Variable_29;

            // 1 - X
            float Variable_26; // 1 - X output 0
            Variable_26 = 1 - Variable_27;

            // MountainsCurve
            float Variable_34; // MountainsCurve output 0
            Variable_34 = MoutainsMask.Eval(Variable_26);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_98; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_98 = FMath::Clamp<float>(Variable_34, 0.000000, 1.000000);

            // *
            float Variable_59; // * output 0
            Variable_59 = Variable_98 * float(3.0f);

            // Max (float)
            float Variable_65; // Max (float) output 0
            Variable_65 = FVoxelNodeFunctions::Max<float>(Variable_90, float(0.0f));

            // -
            float Variable_66; // - output 0
            Variable_66 = Variable_59 - Variable_65;

            // BlendColors.Clamp
            float Variable_45; // BlendColors.Clamp output 0
            Variable_45 = FVoxelNodeFunctions::Clamp(Variable_66, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_124; // BlendColors.Lerp output 0
            Variable_124 = FVoxelNodeFunctions::Lerp(Variable_132, Variable_116, Variable_45);

            // Max (float)
            float Variable_12; // Max (float) output 0
            Variable_12 = FVoxelNodeFunctions::Max<float>(Variable_27, float(0.0f));

            // *
            float Variable_13; // * output 0
            Variable_13 = Variable_12 * ConstantsCache.Variable_15;

            // Min (float)
            float Variable_14; // Min (float) output 0
            Variable_14 = FVoxelNodeFunctions::Min<float>(Variable_13, float(1.0f));

            // -
            float Variable_111; // - output 0
            Variable_111 = ConstantsCache.Variable_107 - Variable_24;

            // Clamp
            float Variable_105; // Clamp output 0
            Variable_105 = FVoxelNodeFunctions::Clamp(Variable_111, float(0.0f), float(1.0f));

            // Min (float)
            float Variable_106; // Min (float) output 0
            Variable_106 = FVoxelNodeFunctions::Min<float>(Variable_14, Variable_105);

            // BlendColors.Clamp
            float Variable_96; // BlendColors.Clamp output 0
            Variable_96 = FVoxelNodeFunctions::Clamp(Variable_106, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_140; // BlendColors.Lerp output 0
            Variable_140 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_112, Variable_124, Variable_96);

            // BlendColors.Lerp
            float Variable_129; // BlendColors.Lerp output 0
            Variable_129 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_62, ConstantsCache.Variable_55, Variable_53);

            // BlendColors.Lerp
            float Variable_137; // BlendColors.Lerp output 0
            Variable_137 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_93, ConstantsCache.Variable_70, Variable_80);

            // BlendColors.Lerp
            float Variable_133; // BlendColors.Lerp output 0
            Variable_133 = FVoxelNodeFunctions::Lerp(Variable_129, Variable_137, Variable_60);

            // BlendColors.Lerp
            float Variable_121; // BlendColors.Lerp output 0
            Variable_121 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_41, ConstantsCache.Variable_47, Variable_35);

            // BlendColors.Lerp
            float Variable_117; // BlendColors.Lerp output 0
            Variable_117 = FVoxelNodeFunctions::Lerp(Variable_121, ConstantsCache.Variable_37, Variable_20);

            // BlendColors.Lerp
            float Variable_125; // BlendColors.Lerp output 0
            Variable_125 = FVoxelNodeFunctions::Lerp(Variable_133, Variable_117, Variable_45);

            // BlendColors.Lerp
            float Variable_141; // BlendColors.Lerp output 0
            Variable_141 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_113, Variable_125, Variable_96);

            // BlendColors.Lerp
            float Variable_130; // BlendColors.Lerp output 0
            Variable_130 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_63, ConstantsCache.Variable_56, Variable_53);

            // BlendColors.Lerp
            float Variable_138; // BlendColors.Lerp output 0
            Variable_138 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_94, ConstantsCache.Variable_71, Variable_80);

            // BlendColors.Lerp
            float Variable_134; // BlendColors.Lerp output 0
            Variable_134 = FVoxelNodeFunctions::Lerp(Variable_130, Variable_138, Variable_60);

            // BlendColors.Lerp
            float Variable_122; // BlendColors.Lerp output 0
            Variable_122 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_42, ConstantsCache.Variable_48, Variable_35);

            // BlendColors.Lerp
            float Variable_118; // BlendColors.Lerp output 0
            Variable_118 = FVoxelNodeFunctions::Lerp(Variable_122, ConstantsCache.Variable_38, Variable_20);

            // BlendColors.Lerp
            float Variable_126; // BlendColors.Lerp output 0
            Variable_126 = FVoxelNodeFunctions::Lerp(Variable_134, Variable_118, Variable_45);

            // BlendColors.Lerp
            float Variable_142; // BlendColors.Lerp output 0
            Variable_142 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_114, Variable_126, Variable_96);

            // BlendColors.Lerp
            float Variable_131; // BlendColors.Lerp output 0
            Variable_131 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_64, ConstantsCache.Variable_57, Variable_53);

            // BlendColors.Lerp
            float Variable_139; // BlendColors.Lerp output 0
            Variable_139 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_95, ConstantsCache.Variable_72, Variable_80);

            // BlendColors.Lerp
            float Variable_135; // BlendColors.Lerp output 0
            Variable_135 = FVoxelNodeFunctions::Lerp(Variable_131, Variable_139, Variable_60);

            // BlendColors.Lerp
            float Variable_123; // BlendColors.Lerp output 0
            Variable_123 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_43, ConstantsCache.Variable_49, Variable_35);

            // BlendColors.Lerp
            float Variable_119; // BlendColors.Lerp output 0
            Variable_119 = FVoxelNodeFunctions::Lerp(Variable_123, ConstantsCache.Variable_39, Variable_20);

            // BlendColors.Lerp
            float Variable_127; // BlendColors.Lerp output 0
            Variable_127 = FVoxelNodeFunctions::Lerp(Variable_135, Variable_119, Variable_45);

            // BlendColors.Lerp
            float Variable_143; // BlendColors.Lerp output 0
            Variable_143 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_115, Variable_127, Variable_96);

            GraphOutputs.Material.SetColor(FLinearColor(Variable_140, Variable_141, Variable_142, Variable_143));
        }

    };
    struct FLocalComputeStruct_LocalValueMaterialCache2DUsage_LOD0
    {
        struct FVoxelGraphOutputs
        {
            float& Value;
            FVoxelMaterial& Material;
            float& Cache2DUsage;
        };
        struct FVoxelConstantsCache
        {
            float Variable_76; // PlainsNoiseFrequency = 0.2 output 0
            float Variable_5; // Radius = 7000.0 output 0
            float Variable_22; // RingEdgesHardness = 10.0 output 0
            float Variable_25; // PI.3.141593 output 0
            float Variable_32; // Width in Degrees = 50.0 output 0
            float Variable_86; // PlainsColorLow output 0
            float Variable_87; // PlainsColorLow output 1
            float Variable_88; // PlainsColorLow output 2
            float Variable_89; // PlainsColorLow output 3
            float Variable_94; // RiverDepth = 100.0 output 0
            float Variable_41; // BaseHeight = 1000.0 output 0
            float Variable_44; // BaseNoiseHeight = 250.0 output 0
            float Variable_47; // BaseNoiseFrquency = 0.005 output 0
            float Variable_50; // MountainsNoiseHeight = 500.0 output 0
            float Variable_53; // MountainsNoiseFrequency = 0.2 output 0
            float Variable_56; // MountainsColorHigh output 0
            float Variable_57; // MountainsColorHigh output 1
            float Variable_58; // MountainsColorHigh output 2
            float Variable_59; // MountainsColorHigh output 3
            float Variable_60; // MountainsColorLowLow output 0
            float Variable_61; // MountainsColorLowLow output 1
            float Variable_62; // MountainsColorLowLow output 2
            float Variable_63; // MountainsColorLowLow output 3
            float Variable_67; // MountainsColorLowHigh output 0
            float Variable_68; // MountainsColorLowHigh output 1
            float Variable_69; // MountainsColorLowHigh output 2
            float Variable_70; // MountainsColorLowHigh output 3
            float Variable_73; // PlainsNoiseHeight = 250.0 output 0
            float Variable_96; // RiverColor output 0
            float Variable_97; // RiverColor output 1
            float Variable_98; // RiverColor output 2
            float Variable_99; // RiverColor output 3
            float Variable_79; // PlainsColorHigh output 0
            float Variable_80; // PlainsColorHigh output 1
            float Variable_81; // PlainsColorHigh output 2
            float Variable_82; // PlainsColorHigh output 3
            float Variable_143; // RingOuterColor output 0
            float Variable_144; // RingOuterColor output 1
            float Variable_145; // RingOuterColor output 2
            float Variable_146; // RingOuterColor output 3
            float Variable_95; // PI.3.141593 output 0
            float Variable_135; // RiverWidth = 1.0 output 0
            float Variable_120; // BeachColor output 0
            float Variable_121; // BeachColor output 1
            float Variable_122; // BeachColor output 2
            float Variable_123; // BeachColor output 3
            float Variable_130; // Scale = 10.0 output 0
            float Variable_141; // PI.3.141593 output 0
            float Variable_139; // Thickness = 500.0 output 0
            float Variable_38; // / output 0
            float Variable_131; // * output 0
            float Variable_140; // * output 0
            float Variable_132; // / output 0
            float Variable_6; // + output 0
            float Variable_37; // - output 0
            float Variable_138; // + output 0
        };
        struct FVoxelCache
        {
            float Variable_0; // X output 0
            float Variable_24; // X output 0
            float Variable_1; // Y output 0
            float Variable_30; // Y output 0
            float Variable_23; // ATAN2 output 0
            float Variable_26; // / output 0
            float Variable_29; // * output 0
            float Variable_46; // * output 0
            float Variable_52; // * output 0
            float Variable_75; // * output 0
            float Variable_112; // 2D Simplex Noise output 0
            float Variable_109; // * output 0
        };

        FLocalComputeStruct_LocalValueMaterialCache2DUsage_LOD0(const float& InScale, const float& InPlainsNoiseHeight, const float& InRingEdgesHardness, const float& InWidth_in_Degrees, const float& InRiverDepth, const float& InThickness, const float& InBaseHeight, const float& InBaseNoiseHeight, const float& InBaseNoiseFrquency, const float& InMountainsNoiseHeight, const float& InRadius, const float& InRiverWidth, const float& InPlainsNoiseFrequency, const float& InMountainsNoiseFrequency, const FRichCurve& InRingShape, const FRichCurve& InMoutainsMask, const FRichCurve& InRiverMask, const FRichCurve& InPlainsNoiseStrength, const FLinearColor& InPlainsColorLow, const FLinearColor& InRiverColor, const FLinearColor& InBeachColor, const FLinearColor& InMountainsColorHigh, const FLinearColor& InMountainsColorLowLow, const FLinearColor& InMountainsColorLowHigh, const FLinearColor& InPlainsColorHigh, const FLinearColor& InRingOuterColor)
            : Scale(InScale)
            , PlainsNoiseHeight(InPlainsNoiseHeight)
            , RingEdgesHardness(InRingEdgesHardness)
            , Width_in_Degrees(InWidth_in_Degrees)
            , RiverDepth(InRiverDepth)
            , Thickness(InThickness)
            , BaseHeight(InBaseHeight)
            , BaseNoiseHeight(InBaseNoiseHeight)
            , BaseNoiseFrquency(InBaseNoiseFrquency)
            , MountainsNoiseHeight(InMountainsNoiseHeight)
            , Radius(InRadius)
            , RiverWidth(InRiverWidth)
            , PlainsNoiseFrequency(InPlainsNoiseFrequency)
            , MountainsNoiseFrequency(InMountainsNoiseFrequency)
            , RingShape(InRingShape)
            , MoutainsMask(InMoutainsMask)
            , RiverMask(InRiverMask)
            , PlainsNoiseStrength(InPlainsNoiseStrength)
            , PlainsColorLow(InPlainsColorLow)
            , RiverColor(InRiverColor)
            , BeachColor(InBeachColor)
            , MountainsColorHigh(InMountainsColorHigh)
            , MountainsColorLowLow(InMountainsColorLowLow)
            , MountainsColorLowHigh(InMountainsColorLowHigh)
            , PlainsColorHigh(InPlainsColorHigh)
            , RingOuterColor(InRingOuterColor)
        {
        }

        void Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            FVoxelCache Cache;

            {
            }

            Function0_Init(InitStruct);

            {
                // PlainsNoiseFrequency = 0.2
                ConstantsCache.Variable_76 = PlainsNoiseFrequency;

                // Radius = 7000.0
                ConstantsCache.Variable_5 = Radius;

                // RingEdgesHardness = 10.0
                ConstantsCache.Variable_22 = RingEdgesHardness;

                // PI.3.141593
                ConstantsCache.Variable_25 = 3.141593;

                // Width in Degrees = 50.0
                ConstantsCache.Variable_32 = Width_in_Degrees;

                // PlainsColorLow
                ConstantsCache.Variable_86 = PlainsColorLow.R;
                ConstantsCache.Variable_87 = PlainsColorLow.G;
                ConstantsCache.Variable_88 = PlainsColorLow.B;
                ConstantsCache.Variable_89 = PlainsColorLow.A;

                // RiverDepth = 100.0
                ConstantsCache.Variable_94 = RiverDepth;

                // BaseHeight = 1000.0
                ConstantsCache.Variable_41 = BaseHeight;

                // BaseNoiseHeight = 250.0
                ConstantsCache.Variable_44 = BaseNoiseHeight;

                // BaseNoiseFrquency = 0.005
                ConstantsCache.Variable_47 = BaseNoiseFrquency;

                // MountainsNoiseHeight = 500.0
                ConstantsCache.Variable_50 = MountainsNoiseHeight;

                // MountainsNoiseFrequency = 0.2
                ConstantsCache.Variable_53 = MountainsNoiseFrequency;

                // MountainsColorHigh
                ConstantsCache.Variable_56 = MountainsColorHigh.R;
                ConstantsCache.Variable_57 = MountainsColorHigh.G;
                ConstantsCache.Variable_58 = MountainsColorHigh.B;
                ConstantsCache.Variable_59 = MountainsColorHigh.A;

                // MountainsColorLowLow
                ConstantsCache.Variable_60 = MountainsColorLowLow.R;
                ConstantsCache.Variable_61 = MountainsColorLowLow.G;
                ConstantsCache.Variable_62 = MountainsColorLowLow.B;
                ConstantsCache.Variable_63 = MountainsColorLowLow.A;

                // MountainsColorLowHigh
                ConstantsCache.Variable_67 = MountainsColorLowHigh.R;
                ConstantsCache.Variable_68 = MountainsColorLowHigh.G;
                ConstantsCache.Variable_69 = MountainsColorLowHigh.B;
                ConstantsCache.Variable_70 = MountainsColorLowHigh.A;

                // PlainsNoiseHeight = 250.0
                ConstantsCache.Variable_73 = PlainsNoiseHeight;

                // RiverColor
                ConstantsCache.Variable_96 = RiverColor.R;
                ConstantsCache.Variable_97 = RiverColor.G;
                ConstantsCache.Variable_98 = RiverColor.B;
                ConstantsCache.Variable_99 = RiverColor.A;

                // PlainsColorHigh
                ConstantsCache.Variable_79 = PlainsColorHigh.R;
                ConstantsCache.Variable_80 = PlainsColorHigh.G;
                ConstantsCache.Variable_81 = PlainsColorHigh.B;
                ConstantsCache.Variable_82 = PlainsColorHigh.A;

                // RingOuterColor
                ConstantsCache.Variable_143 = RingOuterColor.R;
                ConstantsCache.Variable_144 = RingOuterColor.G;
                ConstantsCache.Variable_145 = RingOuterColor.B;
                ConstantsCache.Variable_146 = RingOuterColor.A;

                // PI.3.141593
                ConstantsCache.Variable_95 = 3.141593;

                // RiverWidth = 1.0
                ConstantsCache.Variable_135 = RiverWidth;

                // BeachColor
                ConstantsCache.Variable_120 = BeachColor.R;
                ConstantsCache.Variable_121 = BeachColor.G;
                ConstantsCache.Variable_122 = BeachColor.B;
                ConstantsCache.Variable_123 = BeachColor.A;

                // Scale = 10.0
                ConstantsCache.Variable_130 = Scale;

                // PI.3.141593
                ConstantsCache.Variable_141 = 3.141593;

                // Thickness = 500.0
                ConstantsCache.Variable_139 = Thickness;

                // /
                ConstantsCache.Variable_38 = ConstantsCache.Variable_32 / float(360.0f);

                // *
                ConstantsCache.Variable_131 = ConstantsCache.Variable_5 * ConstantsCache.Variable_130;

                // *
                ConstantsCache.Variable_140 = ConstantsCache.Variable_139 * ConstantsCache.Variable_130;

                // /
                ConstantsCache.Variable_132 = ConstantsCache.Variable_131 / ConstantsCache.Variable_130;

                // +
                ConstantsCache.Variable_6 = ConstantsCache.Variable_131 + ConstantsCache.Variable_140;

                // -
                ConstantsCache.Variable_37 = float(0.5f) - ConstantsCache.Variable_38;

                // +
                ConstantsCache.Variable_138 = ConstantsCache.Variable_131 + ConstantsCache.Variable_140 + float(-5.0f);

            }
        }
        void ComputeX(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_X_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXY(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XY_Compute(GraphOutputs, Cache, Context);
        }
        void ComputeXYZ(FVoxelCache& Cache, const FVoxelContext& Context, FVoxelGraphOutputs& GraphOutputs) const
        {
            Function0_XYZ_Compute(GraphOutputs, Cache, Context);
        }
        void Get(const FVoxelContext&Context, float& Value, FVoxelMaterial& Material, float& Cache2DUsage) const
        {
            FVoxelGraphOutputs GraphOutputs{Value, Material, Cache2DUsage};
            Function0_Compute(GraphOutputs, Context);
        }

    private:
        FVoxelConstantsCache ConstantsCache;
        FastNoise _2D_Simplex_Noise_8760_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15572_Noise;
        FastNoise _2D_Simplex_Noise_Fractal_15573_Noise;
        FastNoise _2D_Perlin_Noise_7437_Noise;
        FastNoise _2D_Simplex_Noise_8761_Noise;

        const float& Scale;
        const float& PlainsNoiseHeight;
        const float& RingEdgesHardness;
        const float& Width_in_Degrees;
        const float& RiverDepth;
        const float& Thickness;
        const float& BaseHeight;
        const float& BaseNoiseHeight;
        const float& BaseNoiseFrquency;
        const float& MountainsNoiseHeight;
        const float& Radius;
        const float& RiverWidth;
        const float& PlainsNoiseFrequency;
        const float& MountainsNoiseFrequency;
        const FRichCurve& RingShape;
        const FRichCurve& MoutainsMask;
        const FRichCurve& RiverMask;
        const FRichCurve& PlainsNoiseStrength;
        const FLinearColor& PlainsColorLow;
        const FLinearColor& RiverColor;
        const FLinearColor& BeachColor;
        const FLinearColor& MountainsColorHigh;
        const FLinearColor& MountainsColorLowLow;
        const FLinearColor& MountainsColorLowHigh;
        const FLinearColor& PlainsColorHigh;
        const FLinearColor& RingOuterColor;

        ///////////////////////////////////////////////////////////////////////
        //////////////////////////// Init functions ///////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_Init(const FVoxelWorldGeneratorInit& InitStruct)
        {
            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15572_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15572_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15572_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15572_Noise.SetFractalOctaves(5);
            _2D_Simplex_Noise_Fractal_15572_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15572_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15572_Noise.SetFractalType(FastNoise::FractalType::FBM);

            // Init of 2D Simplex Noise Fractal
            _2D_Simplex_Noise_Fractal_15573_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_Fractal_15573_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_Fractal_15573_Noise.SetInterp(FastNoise::Interp::Quintic);
            _2D_Simplex_Noise_Fractal_15573_Noise.SetFractalOctaves(8);
            _2D_Simplex_Noise_Fractal_15573_Noise.SetFractalLacunarity(2.0);
            _2D_Simplex_Noise_Fractal_15573_Noise.SetFractalGain(0.5);
            _2D_Simplex_Noise_Fractal_15573_Noise.SetFractalType(FastNoise::FractalType::FBM);

            // Init of 2D Perlin Noise
            _2D_Perlin_Noise_7437_Noise.SetSeed(Seed(1338));
            _2D_Perlin_Noise_7437_Noise.SetFrequency(0.1);
            _2D_Perlin_Noise_7437_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8761_Noise.SetSeed(Seed(1337));
            _2D_Simplex_Noise_8761_Noise.SetFrequency(0.02);
            _2D_Simplex_Noise_8761_Noise.SetInterp(FastNoise::Interp::Quintic);

            // Init of 2D Simplex Noise
            _2D_Simplex_Noise_8760_Noise.SetSeed(Seed(1000));
            _2D_Simplex_Noise_8760_Noise.SetFrequency(0.001);
            _2D_Simplex_Noise_8760_Noise.SetInterp(FastNoise::Interp::Quintic);

        }

        ///////////////////////////////////////////////////////////////////////
        ////////////////////////// Compute functions //////////////////////////
        ///////////////////////////////////////////////////////////////////////

        void Function0_X_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // X
            Cache.Variable_0 = Context.X;

            // X
            Cache.Variable_24 = Context.X;

        }

        void Function0_XY_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // Y
            Cache.Variable_1 = Context.Y;

            // Y
            Cache.Variable_30 = Context.Y;

            // ATAN2
            Cache.Variable_23 = FVoxelNodeFunctions::Atan2(Cache.Variable_30, Cache.Variable_24);

            // /
            Cache.Variable_26 = Cache.Variable_23 / ConstantsCache.Variable_25;

            // *
            Cache.Variable_29 = ConstantsCache.Variable_132 * Cache.Variable_26;

            // *
            Cache.Variable_46 = Cache.Variable_29 * ConstantsCache.Variable_47;

            // *
            Cache.Variable_52 = Cache.Variable_29 * ConstantsCache.Variable_53;

            // *
            Cache.Variable_75 = Cache.Variable_29 * ConstantsCache.Variable_76;

            // 2D Simplex Noise
            Cache.Variable_112 = _2D_Simplex_Noise_8760_Noise.GetSimplex(Cache.Variable_29, Cache.Variable_29);

            // *
            Cache.Variable_109 = Cache.Variable_112 * float(0.1f);

        }

        void Function0_XYZ_Compute(FVoxelGraphOutputs& GraphOutputs, FVoxelCache& Cache, const FVoxelContext& Context) const
        {
            // Z
            float Variable_12; // Z output 0
            Variable_12 = Context.Z;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Cache.Variable_0, Cache.Variable_1, Variable_2);

            // +
            float Variable_31; // + output 0
            Variable_31 = Variable_3 + float(0.001f);

            // /
            float Variable_13; // / output 0
            Variable_13 = Variable_12 / Variable_31;

            // ACOS
            float Variable_14; // ACOS output 0
            Variable_14 = FVoxelNodeFunctions::Acos(Variable_13);

            // /
            float Variable_10; // / output 0
            Variable_10 = Variable_14 / ConstantsCache.Variable_141;

            // 1 - X
            float Variable_11; // 1 - X output 0
            Variable_11 = 1 - Variable_10;

            // Min (float)
            float Variable_9; // Min (float) output 0
            Variable_9 = FVoxelNodeFunctions::Min<float>(Variable_10, Variable_11);

            // -
            float Variable_15; // - output 0
            Variable_15 = Variable_9 - ConstantsCache.Variable_37;

            // /
            float Variable_36; // / output 0
            Variable_36 = Variable_15 / ConstantsCache.Variable_38;

            // 1 - X
            float Variable_35; // 1 - X output 0
            Variable_35 = 1 - Variable_36;

            // RingCurve
            float Variable_39; // RingCurve output 0
            Variable_39 = RingShape.Eval(Variable_35);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_126; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_126 = FMath::Clamp<float>(Variable_39, 0.000000, 1.000000);

            // *
            float Variable_40; // * output 0
            Variable_40 = Variable_126 * ConstantsCache.Variable_41;

            // *
            float Variable_28; // * output 0
            Variable_28 = ConstantsCache.Variable_132 * Variable_10;

            // *
            float Variable_45; // * output 0
            Variable_45 = Variable_28 * ConstantsCache.Variable_47;

            // 2D Simplex Noise Fractal
            float Variable_42; // 2D Simplex Noise Fractal output 0
            Variable_42 = _2D_Simplex_Noise_Fractal_15572_Noise.GetSimplexFractal(Variable_45, Cache.Variable_46);

            // *
            float Variable_43; // * output 0
            Variable_43 = Variable_42 * ConstantsCache.Variable_44;

            // *
            float Variable_51; // * output 0
            Variable_51 = Variable_28 * ConstantsCache.Variable_53;

            // 2D Simplex Noise Fractal
            float Variable_48; // 2D Simplex Noise Fractal output 0
            Variable_48 = _2D_Simplex_Noise_Fractal_15573_Noise.GetSimplexFractal(Variable_51, Cache.Variable_52);

            // MountainsCurve
            float Variable_54; // MountainsCurve output 0
            Variable_54 = MoutainsMask.Eval(Variable_35);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_127; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_127 = FMath::Clamp<float>(Variable_54, 0.000000, 1.000000);

            // *
            float Variable_49; // * output 0
            Variable_49 = Variable_48 * ConstantsCache.Variable_50 * Variable_127;

            // 2D Perlin Noise
            float Variable_64; // 2D Perlin Noise output 0
            Variable_64 = _2D_Perlin_Noise_7437_Noise.GetPerlin(Variable_51, Cache.Variable_52);

            // *
            float Variable_65; // * output 0
            Variable_65 = ConstantsCache.Variable_50 * Variable_127 * Variable_64 * float(0.1f);

            // *
            float Variable_74; // * output 0
            Variable_74 = Variable_28 * ConstantsCache.Variable_76;

            // 2D Simplex Noise
            float Variable_83; // 2D Simplex Noise output 0
            Variable_83 = _2D_Simplex_Noise_8761_Noise.GetSimplex(Variable_74, Cache.Variable_75);

            // Z
            float Variable_104; // Z output 0
            Variable_104 = Context.Z;

            // /
            float Variable_105; // / output 0
            Variable_105 = Variable_104 / Variable_31;

            // +
            float Variable_108; // + output 0
            Variable_108 = Variable_105 + Cache.Variable_109;

            // ACOS
            float Variable_106; // ACOS output 0
            Variable_106 = FVoxelNodeFunctions::Acos(Variable_108);

            // /
            float Variable_103; // / output 0
            Variable_103 = Variable_106 / ConstantsCache.Variable_95;

            // 1 - X
            float Variable_101; // 1 - X output 0
            Variable_101 = 1 - Variable_103;

            // Min (float)
            float Variable_100; // Min (float) output 0
            Variable_100 = FVoxelNodeFunctions::Min<float>(Variable_103, Variable_101);

            // /
            float Variable_102; // / output 0
            Variable_102 = Variable_100 / float(0.5f);

            // 1 - X
            float Variable_110; // 1 - X output 0
            Variable_110 = 1 - Variable_102;

            // *
            float Variable_111; // * output 0
            Variable_111 = Variable_110 * float(20.0f);

            // /
            float Variable_134; // / output 0
            Variable_134 = Variable_111 / ConstantsCache.Variable_135;

            // RiverCurve
            float Variable_92; // RiverCurve output 0
            Variable_92 = RiverMask.Eval(Variable_134);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_129; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_129 = FMath::Clamp<float>(Variable_92, -1.000000, 1.000000);

            // Min (float)
            float Variable_114; // Min (float) output 0
            Variable_114 = FVoxelNodeFunctions::Min<float>(Variable_129, float(0.0f));

            // *
            float Variable_115; // * output 0
            Variable_115 = Variable_114 * float(-1.0f);

            // *
            float Variable_116; // * output 0
            Variable_116 = Variable_83 * Variable_115;

            // 1 - X
            float Variable_117; // 1 - X output 0
            Variable_117 = 1 - Variable_115;

            // -
            float Variable_118; // - output 0
            Variable_118 = Variable_116 - Variable_117;

            // 1 - X
            float Variable_71; // 1 - X output 0
            Variable_71 = 1 - Variable_127;

            // PlainsNoiseStrengthCurve
            float Variable_77; // PlainsNoiseStrengthCurve output 0
            Variable_77 = PlainsNoiseStrength.Eval(Variable_35);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_128; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_128 = FMath::Clamp<float>(Variable_77, 0.000000, 1.000000);

            // *
            float Variable_72; // * output 0
            Variable_72 = Variable_118 * ConstantsCache.Variable_73 * Variable_71 * Variable_128;

            // Max (float)
            float Variable_113; // Max (float) output 0
            Variable_113 = FVoxelNodeFunctions::Max<float>(Variable_129, float(0.0f));

            // *
            float Variable_93; // * output 0
            Variable_93 = Variable_113 * float(-1.0f) * ConstantsCache.Variable_94;

            // +
            float Variable_34; // + output 0
            Variable_34 = Variable_40 + Variable_43 + Variable_49 + Variable_65 + Variable_72 + Variable_93;

            // *
            float Variable_133; // * output 0
            Variable_133 = Variable_34 * ConstantsCache.Variable_130;

            // -
            float Variable_33; // - output 0
            Variable_33 = ConstantsCache.Variable_131 - Variable_133;

            // -
            float Variable_4; // - output 0
            Variable_4 = Variable_33 - Variable_31;

            // -
            float Variable_7; // - output 0
            Variable_7 = Variable_31 - ConstantsCache.Variable_6;

            // Max (float)
            float Variable_8; // Max (float) output 0
            Variable_8 = FVoxelNodeFunctions::Max<float>(Variable_4, Variable_7);

            // -
            float Variable_19; // - output 0
            Variable_19 = Variable_8 - float(1.0f);

            // Max (float)
            float Variable_18; // Max (float) output 0
            Variable_18 = FVoxelNodeFunctions::Max<float>(Variable_36, float(0.0f));

            // *
            float Variable_20; // * output 0
            Variable_20 = Variable_18 * ConstantsCache.Variable_22;

            // Min (float)
            float Variable_21; // Min (float) output 0
            Variable_21 = FVoxelNodeFunctions::Min<float>(Variable_20, float(1.0f));

            // *
            float Variable_16; // * output 0
            Variable_16 = Variable_19 * Variable_21;

            // +
            float Variable_17; // + output 0
            Variable_17 = Variable_16 + float(1.0f);

            GraphOutputs.Value = Variable_17;
            // BlendColors.Clamp
            float Variable_78; // BlendColors.Clamp output 0
            Variable_78 = FVoxelNodeFunctions::Clamp(Variable_118, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_159; // BlendColors.Lerp output 0
            Variable_159 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_86, ConstantsCache.Variable_79, Variable_78);

            // *
            float Variable_125; // * output 0
            Variable_125 = Variable_129 * float(10.0f);

            // BlendColors.Clamp
            float Variable_107; // BlendColors.Clamp output 0
            Variable_107 = FVoxelNodeFunctions::Clamp(Variable_125, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_167; // BlendColors.Lerp output 0
            Variable_167 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_120, ConstantsCache.Variable_96, Variable_107);

            // +
            float Variable_119; // + output 0
            Variable_119 = Variable_129 + float(0.3f);

            // BlendColors.Clamp
            float Variable_85; // BlendColors.Clamp output 0
            Variable_85 = FVoxelNodeFunctions::Clamp(Variable_119, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_163; // BlendColors.Lerp output 0
            Variable_163 = FVoxelNodeFunctions::Lerp(Variable_159, Variable_167, Variable_85);

            // BlendColors.Clamp
            float Variable_55; // BlendColors.Clamp output 0
            Variable_55 = FVoxelNodeFunctions::Clamp(Variable_64, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_151; // BlendColors.Lerp output 0
            Variable_151 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_60, ConstantsCache.Variable_67, Variable_55);

            // BlendColors.Clamp
            float Variable_27; // BlendColors.Clamp output 0
            Variable_27 = FVoxelNodeFunctions::Clamp(Variable_48, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_147; // BlendColors.Lerp output 0
            Variable_147 = FVoxelNodeFunctions::Lerp(Variable_151, ConstantsCache.Variable_56, Variable_27);

            // *
            float Variable_84; // * output 0
            Variable_84 = Variable_127 * float(3.0f);

            // Max (float)
            float Variable_90; // Max (float) output 0
            Variable_90 = FVoxelNodeFunctions::Max<float>(Variable_118, float(0.0f));

            // -
            float Variable_91; // - output 0
            Variable_91 = Variable_84 - Variable_90;

            // BlendColors.Clamp
            float Variable_66; // BlendColors.Clamp output 0
            Variable_66 = FVoxelNodeFunctions::Clamp(Variable_91, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_155; // BlendColors.Lerp output 0
            Variable_155 = FVoxelNodeFunctions::Lerp(Variable_163, Variable_147, Variable_66);

            // -
            float Variable_142; // - output 0
            Variable_142 = ConstantsCache.Variable_138 - Variable_31;

            // Clamp
            float Variable_136; // Clamp output 0
            Variable_136 = FVoxelNodeFunctions::Clamp(Variable_142, float(0.0f), float(1.0f));

            // Min (float)
            float Variable_137; // Min (float) output 0
            Variable_137 = FVoxelNodeFunctions::Min<float>(Variable_21, Variable_136);

            // BlendColors.Clamp
            float Variable_124; // BlendColors.Clamp output 0
            Variable_124 = FVoxelNodeFunctions::Clamp(Variable_137, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_171; // BlendColors.Lerp output 0
            Variable_171 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_143, Variable_155, Variable_124);

            // BlendColors.Lerp
            float Variable_160; // BlendColors.Lerp output 0
            Variable_160 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_87, ConstantsCache.Variable_80, Variable_78);

            // BlendColors.Lerp
            float Variable_168; // BlendColors.Lerp output 0
            Variable_168 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_121, ConstantsCache.Variable_97, Variable_107);

            // BlendColors.Lerp
            float Variable_164; // BlendColors.Lerp output 0
            Variable_164 = FVoxelNodeFunctions::Lerp(Variable_160, Variable_168, Variable_85);

            // BlendColors.Lerp
            float Variable_152; // BlendColors.Lerp output 0
            Variable_152 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_61, ConstantsCache.Variable_68, Variable_55);

            // BlendColors.Lerp
            float Variable_148; // BlendColors.Lerp output 0
            Variable_148 = FVoxelNodeFunctions::Lerp(Variable_152, ConstantsCache.Variable_57, Variable_27);

            // BlendColors.Lerp
            float Variable_156; // BlendColors.Lerp output 0
            Variable_156 = FVoxelNodeFunctions::Lerp(Variable_164, Variable_148, Variable_66);

            // BlendColors.Lerp
            float Variable_172; // BlendColors.Lerp output 0
            Variable_172 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_144, Variable_156, Variable_124);

            // BlendColors.Lerp
            float Variable_161; // BlendColors.Lerp output 0
            Variable_161 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_88, ConstantsCache.Variable_81, Variable_78);

            // BlendColors.Lerp
            float Variable_169; // BlendColors.Lerp output 0
            Variable_169 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_122, ConstantsCache.Variable_98, Variable_107);

            // BlendColors.Lerp
            float Variable_165; // BlendColors.Lerp output 0
            Variable_165 = FVoxelNodeFunctions::Lerp(Variable_161, Variable_169, Variable_85);

            // BlendColors.Lerp
            float Variable_153; // BlendColors.Lerp output 0
            Variable_153 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_62, ConstantsCache.Variable_69, Variable_55);

            // BlendColors.Lerp
            float Variable_149; // BlendColors.Lerp output 0
            Variable_149 = FVoxelNodeFunctions::Lerp(Variable_153, ConstantsCache.Variable_58, Variable_27);

            // BlendColors.Lerp
            float Variable_157; // BlendColors.Lerp output 0
            Variable_157 = FVoxelNodeFunctions::Lerp(Variable_165, Variable_149, Variable_66);

            // BlendColors.Lerp
            float Variable_173; // BlendColors.Lerp output 0
            Variable_173 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_145, Variable_157, Variable_124);

            // BlendColors.Lerp
            float Variable_162; // BlendColors.Lerp output 0
            Variable_162 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_89, ConstantsCache.Variable_82, Variable_78);

            // BlendColors.Lerp
            float Variable_170; // BlendColors.Lerp output 0
            Variable_170 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_123, ConstantsCache.Variable_99, Variable_107);

            // BlendColors.Lerp
            float Variable_166; // BlendColors.Lerp output 0
            Variable_166 = FVoxelNodeFunctions::Lerp(Variable_162, Variable_170, Variable_85);

            // BlendColors.Lerp
            float Variable_154; // BlendColors.Lerp output 0
            Variable_154 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_63, ConstantsCache.Variable_70, Variable_55);

            // BlendColors.Lerp
            float Variable_150; // BlendColors.Lerp output 0
            Variable_150 = FVoxelNodeFunctions::Lerp(Variable_154, ConstantsCache.Variable_59, Variable_27);

            // BlendColors.Lerp
            float Variable_158; // BlendColors.Lerp output 0
            Variable_158 = FVoxelNodeFunctions::Lerp(Variable_166, Variable_150, Variable_66);

            // BlendColors.Lerp
            float Variable_174; // BlendColors.Lerp output 0
            Variable_174 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_146, Variable_158, Variable_124);

            GraphOutputs.Material.SetColor(FLinearColor(Variable_171, Variable_172, Variable_173, Variable_174));
        }

        void Function0_Compute(FVoxelGraphOutputs& GraphOutputs, const FVoxelContext& Context) const
        {
            // Z
            float Variable_12; // Z output 0
            Variable_12 = Context.Z;

            // X
            float Variable_0; // X output 0
            Variable_0 = Context.X;

            // Y
            float Variable_1; // Y output 0
            Variable_1 = Context.Y;

            // Z
            float Variable_2; // Z output 0
            Variable_2 = Context.Z;

            // Vector Length
            float Variable_3; // Vector Length output 0
            Variable_3 = FVoxelNodeFunctions::VectorLength(Variable_0, Variable_1, Variable_2);

            // +
            float Variable_31; // + output 0
            Variable_31 = Variable_3 + float(0.001f);

            // /
            float Variable_13; // / output 0
            Variable_13 = Variable_12 / Variable_31;

            // ACOS
            float Variable_14; // ACOS output 0
            Variable_14 = FVoxelNodeFunctions::Acos(Variable_13);

            // /
            float Variable_10; // / output 0
            Variable_10 = Variable_14 / ConstantsCache.Variable_141;

            // 1 - X
            float Variable_11; // 1 - X output 0
            Variable_11 = 1 - Variable_10;

            // Min (float)
            float Variable_9; // Min (float) output 0
            Variable_9 = FVoxelNodeFunctions::Min<float>(Variable_10, Variable_11);

            // -
            float Variable_15; // - output 0
            Variable_15 = Variable_9 - ConstantsCache.Variable_37;

            // /
            float Variable_36; // / output 0
            Variable_36 = Variable_15 / ConstantsCache.Variable_38;

            // 1 - X
            float Variable_35; // 1 - X output 0
            Variable_35 = 1 - Variable_36;

            // RingCurve
            float Variable_39; // RingCurve output 0
            Variable_39 = RingShape.Eval(Variable_35);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_126; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_126 = FMath::Clamp<float>(Variable_39, 0.000000, 1.000000);

            // *
            float Variable_40; // * output 0
            Variable_40 = Variable_126 * ConstantsCache.Variable_41;

            // *
            float Variable_28; // * output 0
            Variable_28 = ConstantsCache.Variable_132 * Variable_10;

            // *
            float Variable_45; // * output 0
            Variable_45 = Variable_28 * ConstantsCache.Variable_47;

            // Y
            float Variable_30; // Y output 0
            Variable_30 = Context.Y;

            // X
            float Variable_24; // X output 0
            Variable_24 = Context.X;

            // ATAN2
            float Variable_23; // ATAN2 output 0
            Variable_23 = FVoxelNodeFunctions::Atan2(Variable_30, Variable_24);

            // /
            float Variable_26; // / output 0
            Variable_26 = Variable_23 / ConstantsCache.Variable_25;

            // *
            float Variable_29; // * output 0
            Variable_29 = ConstantsCache.Variable_132 * Variable_26;

            // *
            float Variable_46; // * output 0
            Variable_46 = Variable_29 * ConstantsCache.Variable_47;

            // 2D Simplex Noise Fractal
            float Variable_42; // 2D Simplex Noise Fractal output 0
            Variable_42 = _2D_Simplex_Noise_Fractal_15572_Noise.GetSimplexFractal(Variable_45, Variable_46);

            // *
            float Variable_43; // * output 0
            Variable_43 = Variable_42 * ConstantsCache.Variable_44;

            // *
            float Variable_51; // * output 0
            Variable_51 = Variable_28 * ConstantsCache.Variable_53;

            // *
            float Variable_52; // * output 0
            Variable_52 = Variable_29 * ConstantsCache.Variable_53;

            // 2D Simplex Noise Fractal
            float Variable_48; // 2D Simplex Noise Fractal output 0
            Variable_48 = _2D_Simplex_Noise_Fractal_15573_Noise.GetSimplexFractal(Variable_51, Variable_52);

            // MountainsCurve
            float Variable_54; // MountainsCurve output 0
            Variable_54 = MoutainsMask.Eval(Variable_35);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_127; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_127 = FMath::Clamp<float>(Variable_54, 0.000000, 1.000000);

            // *
            float Variable_49; // * output 0
            Variable_49 = Variable_48 * ConstantsCache.Variable_50 * Variable_127;

            // 2D Perlin Noise
            float Variable_64; // 2D Perlin Noise output 0
            Variable_64 = _2D_Perlin_Noise_7437_Noise.GetPerlin(Variable_51, Variable_52);

            // *
            float Variable_65; // * output 0
            Variable_65 = ConstantsCache.Variable_50 * Variable_127 * Variable_64 * float(0.1f);

            // *
            float Variable_74; // * output 0
            Variable_74 = Variable_28 * ConstantsCache.Variable_76;

            // *
            float Variable_75; // * output 0
            Variable_75 = Variable_29 * ConstantsCache.Variable_76;

            // 2D Simplex Noise
            float Variable_83; // 2D Simplex Noise output 0
            Variable_83 = _2D_Simplex_Noise_8761_Noise.GetSimplex(Variable_74, Variable_75);

            // Z
            float Variable_104; // Z output 0
            Variable_104 = Context.Z;

            // /
            float Variable_105; // / output 0
            Variable_105 = Variable_104 / Variable_31;

            // 2D Simplex Noise
            float Variable_112; // 2D Simplex Noise output 0
            Variable_112 = _2D_Simplex_Noise_8760_Noise.GetSimplex(Variable_29, Variable_29);

            // *
            float Variable_109; // * output 0
            Variable_109 = Variable_112 * float(0.1f);

            // +
            float Variable_108; // + output 0
            Variable_108 = Variable_105 + Variable_109;

            // ACOS
            float Variable_106; // ACOS output 0
            Variable_106 = FVoxelNodeFunctions::Acos(Variable_108);

            // /
            float Variable_103; // / output 0
            Variable_103 = Variable_106 / ConstantsCache.Variable_95;

            // 1 - X
            float Variable_101; // 1 - X output 0
            Variable_101 = 1 - Variable_103;

            // Min (float)
            float Variable_100; // Min (float) output 0
            Variable_100 = FVoxelNodeFunctions::Min<float>(Variable_103, Variable_101);

            // /
            float Variable_102; // / output 0
            Variable_102 = Variable_100 / float(0.5f);

            // 1 - X
            float Variable_110; // 1 - X output 0
            Variable_110 = 1 - Variable_102;

            // *
            float Variable_111; // * output 0
            Variable_111 = Variable_110 * float(20.0f);

            // /
            float Variable_134; // / output 0
            Variable_134 = Variable_111 / ConstantsCache.Variable_135;

            // RiverCurve
            float Variable_92; // RiverCurve output 0
            Variable_92 = RiverMask.Eval(Variable_134);

            // Static Clamp: -1.0 <= X <= 1.0
            float Variable_129; // Static Clamp: -1.0 <= X <= 1.0 output 0
            Variable_129 = FMath::Clamp<float>(Variable_92, -1.000000, 1.000000);

            // Min (float)
            float Variable_114; // Min (float) output 0
            Variable_114 = FVoxelNodeFunctions::Min<float>(Variable_129, float(0.0f));

            // *
            float Variable_115; // * output 0
            Variable_115 = Variable_114 * float(-1.0f);

            // *
            float Variable_116; // * output 0
            Variable_116 = Variable_83 * Variable_115;

            // 1 - X
            float Variable_117; // 1 - X output 0
            Variable_117 = 1 - Variable_115;

            // -
            float Variable_118; // - output 0
            Variable_118 = Variable_116 - Variable_117;

            // 1 - X
            float Variable_71; // 1 - X output 0
            Variable_71 = 1 - Variable_127;

            // PlainsNoiseStrengthCurve
            float Variable_77; // PlainsNoiseStrengthCurve output 0
            Variable_77 = PlainsNoiseStrength.Eval(Variable_35);

            // Static Clamp: 0.0 <= X <= 1.0
            float Variable_128; // Static Clamp: 0.0 <= X <= 1.0 output 0
            Variable_128 = FMath::Clamp<float>(Variable_77, 0.000000, 1.000000);

            // *
            float Variable_72; // * output 0
            Variable_72 = Variable_118 * ConstantsCache.Variable_73 * Variable_71 * Variable_128;

            // Max (float)
            float Variable_113; // Max (float) output 0
            Variable_113 = FVoxelNodeFunctions::Max<float>(Variable_129, float(0.0f));

            // *
            float Variable_93; // * output 0
            Variable_93 = Variable_113 * float(-1.0f) * ConstantsCache.Variable_94;

            // +
            float Variable_34; // + output 0
            Variable_34 = Variable_40 + Variable_43 + Variable_49 + Variable_65 + Variable_72 + Variable_93;

            // *
            float Variable_133; // * output 0
            Variable_133 = Variable_34 * ConstantsCache.Variable_130;

            // -
            float Variable_33; // - output 0
            Variable_33 = ConstantsCache.Variable_131 - Variable_133;

            // -
            float Variable_4; // - output 0
            Variable_4 = Variable_33 - Variable_31;

            // -
            float Variable_7; // - output 0
            Variable_7 = Variable_31 - ConstantsCache.Variable_6;

            // Max (float)
            float Variable_8; // Max (float) output 0
            Variable_8 = FVoxelNodeFunctions::Max<float>(Variable_4, Variable_7);

            // -
            float Variable_19; // - output 0
            Variable_19 = Variable_8 - float(1.0f);

            // Max (float)
            float Variable_18; // Max (float) output 0
            Variable_18 = FVoxelNodeFunctions::Max<float>(Variable_36, float(0.0f));

            // *
            float Variable_20; // * output 0
            Variable_20 = Variable_18 * ConstantsCache.Variable_22;

            // Min (float)
            float Variable_21; // Min (float) output 0
            Variable_21 = FVoxelNodeFunctions::Min<float>(Variable_20, float(1.0f));

            // *
            float Variable_16; // * output 0
            Variable_16 = Variable_19 * Variable_21;

            // +
            float Variable_17; // + output 0
            Variable_17 = Variable_16 + float(1.0f);

            GraphOutputs.Value = Variable_17;
            // BlendColors.Clamp
            float Variable_78; // BlendColors.Clamp output 0
            Variable_78 = FVoxelNodeFunctions::Clamp(Variable_118, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_159; // BlendColors.Lerp output 0
            Variable_159 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_86, ConstantsCache.Variable_79, Variable_78);

            // *
            float Variable_125; // * output 0
            Variable_125 = Variable_129 * float(10.0f);

            // BlendColors.Clamp
            float Variable_107; // BlendColors.Clamp output 0
            Variable_107 = FVoxelNodeFunctions::Clamp(Variable_125, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_167; // BlendColors.Lerp output 0
            Variable_167 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_120, ConstantsCache.Variable_96, Variable_107);

            // +
            float Variable_119; // + output 0
            Variable_119 = Variable_129 + float(0.3f);

            // BlendColors.Clamp
            float Variable_85; // BlendColors.Clamp output 0
            Variable_85 = FVoxelNodeFunctions::Clamp(Variable_119, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_163; // BlendColors.Lerp output 0
            Variable_163 = FVoxelNodeFunctions::Lerp(Variable_159, Variable_167, Variable_85);

            // BlendColors.Clamp
            float Variable_55; // BlendColors.Clamp output 0
            Variable_55 = FVoxelNodeFunctions::Clamp(Variable_64, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_151; // BlendColors.Lerp output 0
            Variable_151 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_60, ConstantsCache.Variable_67, Variable_55);

            // BlendColors.Clamp
            float Variable_27; // BlendColors.Clamp output 0
            Variable_27 = FVoxelNodeFunctions::Clamp(Variable_48, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_147; // BlendColors.Lerp output 0
            Variable_147 = FVoxelNodeFunctions::Lerp(Variable_151, ConstantsCache.Variable_56, Variable_27);

            // *
            float Variable_84; // * output 0
            Variable_84 = Variable_127 * float(3.0f);

            // Max (float)
            float Variable_90; // Max (float) output 0
            Variable_90 = FVoxelNodeFunctions::Max<float>(Variable_118, float(0.0f));

            // -
            float Variable_91; // - output 0
            Variable_91 = Variable_84 - Variable_90;

            // BlendColors.Clamp
            float Variable_66; // BlendColors.Clamp output 0
            Variable_66 = FVoxelNodeFunctions::Clamp(Variable_91, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_155; // BlendColors.Lerp output 0
            Variable_155 = FVoxelNodeFunctions::Lerp(Variable_163, Variable_147, Variable_66);

            // -
            float Variable_142; // - output 0
            Variable_142 = ConstantsCache.Variable_138 - Variable_31;

            // Clamp
            float Variable_136; // Clamp output 0
            Variable_136 = FVoxelNodeFunctions::Clamp(Variable_142, float(0.0f), float(1.0f));

            // Min (float)
            float Variable_137; // Min (float) output 0
            Variable_137 = FVoxelNodeFunctions::Min<float>(Variable_21, Variable_136);

            // BlendColors.Clamp
            float Variable_124; // BlendColors.Clamp output 0
            Variable_124 = FVoxelNodeFunctions::Clamp(Variable_137, float(0.0f), float(1.0f));

            // BlendColors.Lerp
            float Variable_171; // BlendColors.Lerp output 0
            Variable_171 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_143, Variable_155, Variable_124);

            // BlendColors.Lerp
            float Variable_160; // BlendColors.Lerp output 0
            Variable_160 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_87, ConstantsCache.Variable_80, Variable_78);

            // BlendColors.Lerp
            float Variable_168; // BlendColors.Lerp output 0
            Variable_168 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_121, ConstantsCache.Variable_97, Variable_107);

            // BlendColors.Lerp
            float Variable_164; // BlendColors.Lerp output 0
            Variable_164 = FVoxelNodeFunctions::Lerp(Variable_160, Variable_168, Variable_85);

            // BlendColors.Lerp
            float Variable_152; // BlendColors.Lerp output 0
            Variable_152 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_61, ConstantsCache.Variable_68, Variable_55);

            // BlendColors.Lerp
            float Variable_148; // BlendColors.Lerp output 0
            Variable_148 = FVoxelNodeFunctions::Lerp(Variable_152, ConstantsCache.Variable_57, Variable_27);

            // BlendColors.Lerp
            float Variable_156; // BlendColors.Lerp output 0
            Variable_156 = FVoxelNodeFunctions::Lerp(Variable_164, Variable_148, Variable_66);

            // BlendColors.Lerp
            float Variable_172; // BlendColors.Lerp output 0
            Variable_172 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_144, Variable_156, Variable_124);

            // BlendColors.Lerp
            float Variable_161; // BlendColors.Lerp output 0
            Variable_161 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_88, ConstantsCache.Variable_81, Variable_78);

            // BlendColors.Lerp
            float Variable_169; // BlendColors.Lerp output 0
            Variable_169 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_122, ConstantsCache.Variable_98, Variable_107);

            // BlendColors.Lerp
            float Variable_165; // BlendColors.Lerp output 0
            Variable_165 = FVoxelNodeFunctions::Lerp(Variable_161, Variable_169, Variable_85);

            // BlendColors.Lerp
            float Variable_153; // BlendColors.Lerp output 0
            Variable_153 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_62, ConstantsCache.Variable_69, Variable_55);

            // BlendColors.Lerp
            float Variable_149; // BlendColors.Lerp output 0
            Variable_149 = FVoxelNodeFunctions::Lerp(Variable_153, ConstantsCache.Variable_58, Variable_27);

            // BlendColors.Lerp
            float Variable_157; // BlendColors.Lerp output 0
            Variable_157 = FVoxelNodeFunctions::Lerp(Variable_165, Variable_149, Variable_66);

            // BlendColors.Lerp
            float Variable_173; // BlendColors.Lerp output 0
            Variable_173 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_145, Variable_157, Variable_124);

            // BlendColors.Lerp
            float Variable_162; // BlendColors.Lerp output 0
            Variable_162 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_89, ConstantsCache.Variable_82, Variable_78);

            // BlendColors.Lerp
            float Variable_170; // BlendColors.Lerp output 0
            Variable_170 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_123, ConstantsCache.Variable_99, Variable_107);

            // BlendColors.Lerp
            float Variable_166; // BlendColors.Lerp output 0
            Variable_166 = FVoxelNodeFunctions::Lerp(Variable_162, Variable_170, Variable_85);

            // BlendColors.Lerp
            float Variable_154; // BlendColors.Lerp output 0
            Variable_154 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_63, ConstantsCache.Variable_70, Variable_55);

            // BlendColors.Lerp
            float Variable_150; // BlendColors.Lerp output 0
            Variable_150 = FVoxelNodeFunctions::Lerp(Variable_154, ConstantsCache.Variable_59, Variable_27);

            // BlendColors.Lerp
            float Variable_158; // BlendColors.Lerp output 0
            Variable_158 = FVoxelNodeFunctions::Lerp(Variable_166, Variable_150, Variable_66);

            // BlendColors.Lerp
            float Variable_174; // BlendColors.Lerp output 0
            Variable_174 = FVoxelNodeFunctions::Lerp(ConstantsCache.Variable_146, Variable_158, Variable_124);

            GraphOutputs.Material.SetColor(FLinearColor(Variable_171, Variable_172, Variable_173, Variable_174));
        }

    };

    FRingWorldInstance(const float& InScale, const float& InPlainsNoiseHeight, const float& InRingEdgesHardness, const float& InWidth_in_Degrees, const float& InRiverDepth, const float& InThickness, const float& InBaseHeight, const float& InBaseNoiseHeight, const float& InBaseNoiseFrquency, const float& InMountainsNoiseHeight, const float& InRadius, const float& InRiverWidth, const float& InPlainsNoiseFrequency, const float& InMountainsNoiseFrequency, const FRichCurve& InRingShape, const FRichCurve& InMoutainsMask, const FRichCurve& InRiverMask, const FRichCurve& InPlainsNoiseStrength, const FLinearColor& InPlainsColorLow, const FLinearColor& InRiverColor, const FLinearColor& InBeachColor, const FLinearColor& InMountainsColorHigh, const FLinearColor& InMountainsColorLowLow, const FLinearColor& InMountainsColorLowHigh, const FLinearColor& InPlainsColorHigh, const FLinearColor& InRingOuterColor)
        : Scale(InScale)
        , PlainsNoiseHeight(InPlainsNoiseHeight)
        , RingEdgesHardness(InRingEdgesHardness)
        , Width_in_Degrees(InWidth_in_Degrees)
        , RiverDepth(InRiverDepth)
        , Thickness(InThickness)
        , BaseHeight(InBaseHeight)
        , BaseNoiseHeight(InBaseNoiseHeight)
        , BaseNoiseFrquency(InBaseNoiseFrquency)
        , MountainsNoiseHeight(InMountainsNoiseHeight)
        , Radius(InRadius)
        , RiverWidth(InRiverWidth)
        , PlainsNoiseFrequency(InPlainsNoiseFrequency)
        , MountainsNoiseFrequency(InMountainsNoiseFrequency)
        , RingShape(InRingShape)
        , MoutainsMask(InMoutainsMask)
        , RiverMask(InRiverMask)
        , PlainsNoiseStrength(InPlainsNoiseStrength)
        , PlainsColorLow(InPlainsColorLow)
        , RiverColor(InRiverColor)
        , BeachColor(InBeachColor)
        , MountainsColorHigh(InMountainsColorHigh)
        , MountainsColorLowLow(InMountainsColorLowLow)
        , MountainsColorLowHigh(InMountainsColorLowHigh)
        , PlainsColorHigh(InPlainsColorHigh)
        , RingOuterColor(InRingOuterColor)
        , FVoxelWorldGeneratorInstance(
        {
            {"Value", 0}
        },
        {
        })
        , LocalValue_LOD0(Scale, PlainsNoiseHeight, RingEdgesHardness, Width_in_Degrees, RiverDepth, Thickness, BaseHeight, BaseNoiseHeight, BaseNoiseFrquency, MountainsNoiseHeight, Radius, RiverWidth, PlainsNoiseFrequency, MountainsNoiseFrequency, RingShape, MoutainsMask, RiverMask, PlainsNoiseStrength, PlainsColorLow, RiverColor, BeachColor, MountainsColorHigh, MountainsColorLowLow, MountainsColorLowHigh, PlainsColorHigh, RingOuterColor)
        , LocalMaterial_LOD0(Scale, PlainsNoiseHeight, RingEdgesHardness, Width_in_Degrees, RiverDepth, Thickness, BaseHeight, BaseNoiseHeight, BaseNoiseFrquency, MountainsNoiseHeight, Radius, RiverWidth, PlainsNoiseFrequency, MountainsNoiseFrequency, RingShape, MoutainsMask, RiverMask, PlainsNoiseStrength, PlainsColorLow, RiverColor, BeachColor, MountainsColorHigh, MountainsColorLowLow, MountainsColorLowHigh, PlainsColorHigh, RingOuterColor)
        , LocalValueMaterial_LOD0(Scale, PlainsNoiseHeight, RingEdgesHardness, Width_in_Degrees, RiverDepth, Thickness, BaseHeight, BaseNoiseHeight, BaseNoiseFrquency, MountainsNoiseHeight, Radius, RiverWidth, PlainsNoiseFrequency, MountainsNoiseFrequency, RingShape, MoutainsMask, RiverMask, PlainsNoiseStrength, PlainsColorLow, RiverColor, BeachColor, MountainsColorHigh, MountainsColorLowLow, MountainsColorLowHigh, PlainsColorHigh, RingOuterColor)
        , LocalUpVectorXUpVectorYUpVectorZ_LOD0(Scale, PlainsNoiseHeight, RingEdgesHardness, Width_in_Degrees, RiverDepth, Thickness, BaseHeight, BaseNoiseHeight, BaseNoiseFrquency, MountainsNoiseHeight, Radius, RiverWidth, PlainsNoiseFrequency, MountainsNoiseFrequency, RingShape, MoutainsMask, RiverMask, PlainsNoiseStrength, PlainsColorLow, RiverColor, BeachColor, MountainsColorHigh, MountainsColorLowLow, MountainsColorLowHigh, PlainsColorHigh, RingOuterColor)
        , LocalValueRangeAnalysis_LOD0(Scale, PlainsNoiseHeight, RingEdgesHardness, Width_in_Degrees, RiverDepth, Thickness, BaseHeight, BaseNoiseHeight, BaseNoiseFrquency, MountainsNoiseHeight, Radius, RiverWidth, PlainsNoiseFrequency, MountainsNoiseFrequency, RingShape, MoutainsMask, RiverMask, PlainsNoiseStrength, PlainsColorLow, RiverColor, BeachColor, MountainsColorHigh, MountainsColorLowLow, MountainsColorLowHigh, PlainsColorHigh, RingOuterColor)
        , LocalValueCache2DCache_LOD0(Scale, PlainsNoiseHeight, RingEdgesHardness, Width_in_Degrees, RiverDepth, Thickness, BaseHeight, BaseNoiseHeight, BaseNoiseFrquency, MountainsNoiseHeight, Radius, RiverWidth, PlainsNoiseFrequency, MountainsNoiseFrequency, RingShape, MoutainsMask, RiverMask, PlainsNoiseStrength, PlainsColorLow, RiverColor, BeachColor, MountainsColorHigh, MountainsColorLowLow, MountainsColorLowHigh, PlainsColorHigh, RingOuterColor)
        , LocalValueCache2DUsage_LOD0(Scale, PlainsNoiseHeight, RingEdgesHardness, Width_in_Degrees, RiverDepth, Thickness, BaseHeight, BaseNoiseHeight, BaseNoiseFrquency, MountainsNoiseHeight, Radius, RiverWidth, PlainsNoiseFrequency, MountainsNoiseFrequency, RingShape, MoutainsMask, RiverMask, PlainsNoiseStrength, PlainsColorLow, RiverColor, BeachColor, MountainsColorHigh, MountainsColorLowLow, MountainsColorLowHigh, PlainsColorHigh, RingOuterColor)
        , LocalMaterialCache2DUsage_LOD0(Scale, PlainsNoiseHeight, RingEdgesHardness, Width_in_Degrees, RiverDepth, Thickness, BaseHeight, BaseNoiseHeight, BaseNoiseFrquency, MountainsNoiseHeight, Radius, RiverWidth, PlainsNoiseFrequency, MountainsNoiseFrequency, RingShape, MoutainsMask, RiverMask, PlainsNoiseStrength, PlainsColorLow, RiverColor, BeachColor, MountainsColorHigh, MountainsColorLowLow, MountainsColorLowHigh, PlainsColorHigh, RingOuterColor)
        , LocalValueMaterialCache2DUsage_LOD0(Scale, PlainsNoiseHeight, RingEdgesHardness, Width_in_Degrees, RiverDepth, Thickness, BaseHeight, BaseNoiseHeight, BaseNoiseFrquency, MountainsNoiseHeight, Radius, RiverWidth, PlainsNoiseFrequency, MountainsNoiseFrequency, RingShape, MoutainsMask, RiverMask, PlainsNoiseStrength, PlainsColorLow, RiverColor, BeachColor, MountainsColorHigh, MountainsColorLowLow, MountainsColorLowHigh, PlainsColorHigh, RingOuterColor)
    {
    }

    virtual void Init(const FVoxelWorldGeneratorInit& InitStruct) final
    {
        LocalValue_LOD0.Init(InitStruct);
        LocalMaterial_LOD0.Init(InitStruct);
        LocalValueMaterial_LOD0.Init(InitStruct);
        LocalUpVectorXUpVectorYUpVectorZ_LOD0.Init(InitStruct);
        LocalValueRangeAnalysis_LOD0.Init(InitStruct);
        LocalValueCache2DCache_LOD0.Init(InitStruct);
        LocalValueCache2DUsage_LOD0.Init(InitStruct);
        LocalMaterialCache2DUsage_LOD0.Init(InitStruct);
        LocalValueMaterialCache2DUsage_LOD0.Init(InitStruct);
    }
    void GetValueAndMaterialInternal(int32 X, int32 Y, int32 Z, FVoxelValue* OutValue, FVoxelMaterial* OutMaterial, int32 QueryLOD, const FVoxelPlaceableItemHolder& ItemHolder) const final
    {
        FVoxelContext Context(ItemHolder, QueryLOD, X, Y, Z);
        if (OutValue && OutMaterial)
        {
            float TmpValue = 1;
            if (0 <= QueryLOD)
            {
                LocalValueMaterial_LOD0.Get(Context, TmpValue, *OutMaterial);
            }
            else
            {
                LocalValueMaterial_LOD0.Get(Context, TmpValue, *OutMaterial);
            }
            *OutValue = TmpValue;
        }
        else if (OutValue)
        {
            float TmpValue = 1;
            if (0 <= QueryLOD)
            {
                LocalValue_LOD0.Get(Context, TmpValue);
            }
            else
            {
                LocalValue_LOD0.Get(Context, TmpValue);
            }
            *OutValue = TmpValue;
        }
        else if (OutMaterial)
        {
            if (0 <= QueryLOD)
            {
                LocalMaterial_LOD0.Get(Context, *OutMaterial);
            }
            else
            {
                LocalMaterial_LOD0.Get(Context, *OutMaterial);
            }
        }
    }
    virtual void GetValuesAndMaterials(FVoxelValue Values[], FVoxelMaterial Materials[], const FVoxelWorldGeneratorQueryZone& QueryZone, int32 QueryLOD, const FVoxelPlaceableItemHolder& ItemHolder) const final
    {
        if (Values && Materials)
        {
            if (0 <= QueryLOD)
            {
                GetLocalValueMaterial_LOD0(Values, Materials, QueryZone, QueryLOD, ItemHolder);
            }
            else
            {
                GetLocalValueMaterial_LOD0(Values, Materials, QueryZone, QueryLOD, ItemHolder);
            }
        }
        else if (Values)
        {
            if (0 <= QueryLOD)
            {
                GetLocalValue_LOD0(Values, Materials, QueryZone, QueryLOD, ItemHolder);
            }
            else
            {
                GetLocalValue_LOD0(Values, Materials, QueryZone, QueryLOD, ItemHolder);
            }
        }
        else if (Materials)
        {
            if (0 <= QueryLOD)
            {
                GetLocalMaterial_LOD0(Values, Materials, QueryZone, QueryLOD, ItemHolder);
            }
            else
            {
                GetLocalMaterial_LOD0(Values, Materials, QueryZone, QueryLOD, ItemHolder);
            }
        }
    }
    virtual int32 GetIntOutput(int32 X, int32 Y, int32 Z, uint8 Index) const final
    {
        return 0;
    }
    virtual float GetFloatOutput(int32 X, int32 Y, int32 Z, uint8 Index) const final
    {
        if (Index == 0)
        {
            float TmpValue = 0;
            LocalValue_LOD0.Get(FVoxelContext(X, Y, Z), TmpValue);
            return TmpValue;
        }
        return 0;
    }
    virtual FVector GetUpVector(int32 X, int32 Y, int32 Z) const final
    {
        FVector Result = FVector::UpVector;
        LocalUpVectorXUpVectorYUpVectorZ_LOD0.Get(FVoxelContext(X, Y, Z), Result.X, Result.Y, Result.Z);
        return Result.GetSafeNormal();
    }
    virtual EVoxelEmptyState IsEmpty(const FIntBox& Bounds, int32 LOD) const final
    {
        FVoxelRangeFailStatus::Reset();
        int32 Step = 1 << LOD;
        TVoxelRange<float> Value = 1;
        LocalValueRangeAnalysis_LOD0.Get(FVoxelContextRange(LOD,{ Bounds.Min.X, Bounds.Max.X - Step },{ Bounds.Min.Y, Bounds.Max.Y - Step },{ Bounds.Min.Z, Bounds.Max.Z - Step }), Value);
        if (FVoxelRangeFailStatus::HasFailed())
        {
            return EVoxelEmptyState::Unknown;
        }
        FVoxelValue Min(Value.Min);
        FVoxelValue Max(Value.Max);
        if (Min.IsEmpty() && Max.IsEmpty())
        {
            return EVoxelEmptyState::AllEmpty;
        }
        else if (!Min.IsEmpty() && !Max.IsEmpty())
        {
            return EVoxelEmptyState::AllFull;
        }
        else
        {
            return EVoxelEmptyState::Unknown;
        }
    }

public:
    void GetLocalValue_LOD0(FVoxelValue Values[], FVoxelMaterial Materials[], const FVoxelWorldGeneratorQueryZone& QueryZone, int32 QueryLOD, const FVoxelPlaceableItemHolder& ItemHolder) const
    {
        FVoxelContext Context(ItemHolder, QueryLOD);
        FLocalComputeStruct_LocalValue_LOD0::FVoxelCache Cache;

        float Value = 1;
        FVoxelMaterial Material;
        FLocalComputeStruct_LocalValue_LOD0::FVoxelGraphOutputs GraphOutputs{Value};

        for (int32 X : QueryZone.XIt())
        {
            Context.X = X;

            LocalValue_LOD0.ComputeX(Cache, Context, GraphOutputs);
            for (int32 Y : QueryZone.YIt())
            {
                Context.Y = Y;

                LocalValue_LOD0.ComputeXY(Cache, Context, GraphOutputs);
                for (int32 Z : QueryZone.ZIt())
                {
                    Context.Z = Z;

                    Value = 1;
                    LocalValue_LOD0.ComputeXYZ(Cache, Context, GraphOutputs);
                    SetValueAndMaterial(Values, Materials, QueryZone, QueryLOD, ItemHolder, X, Y, Z, Value, Material);
                }
            }
        }
    }
    void GetLocalValueCache2DUsage_LOD0(FVoxelValue Values[], FVoxelMaterial Materials[], const float Cache2DValues[], const FVoxelWorldGeneratorQueryZone& QueryZone, const FVoxelPlaceableItemHolder& ItemHolder) const
    {
        FVoxelContext Context(ItemHolder, 0);
        FLocalComputeStruct_LocalValueCache2DUsage_LOD0::FVoxelCache Cache;

        float Value = 1;
        FVoxelMaterial Material;
        float CacheValue = 0;
        FLocalComputeStruct_LocalValueCache2DUsage_LOD0::FVoxelGraphOutputs GraphOutputs{Value, CacheValue};

        for (int32 X : QueryZone.XIt())
        {
            Context.X = X;

            LocalValueCache2DUsage_LOD0.ComputeX(Cache, Context, GraphOutputs);
            for (int32 Y : QueryZone.YIt())
            {
                Context.Y = Y;

                CacheValue = Cache2DValues[QueryZone.GetCache2DIndex(X, Y)];

                LocalValueCache2DUsage_LOD0.ComputeXY(Cache, Context, GraphOutputs);
                for (int32 Z : QueryZone.ZIt())
                {
                    Context.Z = Z;

                    Value = 1;
                    LocalValueCache2DUsage_LOD0.ComputeXYZ(Cache, Context, GraphOutputs);
                    SetValueAndMaterial(Values, Materials, QueryZone, 0, ItemHolder, X, Y, Z, Value, Material);
                }
            }
        }
    }
    void GetLocalMaterial_LOD0(FVoxelValue Values[], FVoxelMaterial Materials[], const FVoxelWorldGeneratorQueryZone& QueryZone, int32 QueryLOD, const FVoxelPlaceableItemHolder& ItemHolder) const
    {
        FVoxelContext Context(ItemHolder, QueryLOD);
        FLocalComputeStruct_LocalMaterial_LOD0::FVoxelCache Cache;

        float Value = 1;
        FVoxelMaterial Material;
        FLocalComputeStruct_LocalMaterial_LOD0::FVoxelGraphOutputs GraphOutputs{Material};

        for (int32 X : QueryZone.XIt())
        {
            Context.X = X;

            LocalMaterial_LOD0.ComputeX(Cache, Context, GraphOutputs);
            for (int32 Y : QueryZone.YIt())
            {
                Context.Y = Y;

                LocalMaterial_LOD0.ComputeXY(Cache, Context, GraphOutputs);
                for (int32 Z : QueryZone.ZIt())
                {
                    Context.Z = Z;

                    Material = FVoxelMaterial();
                    LocalMaterial_LOD0.ComputeXYZ(Cache, Context, GraphOutputs);
                    SetValueAndMaterial(Values, Materials, QueryZone, QueryLOD, ItemHolder, X, Y, Z, Value, Material);
                }
            }
        }
    }
    void GetLocalMaterialCache2DUsage_LOD0(FVoxelValue Values[], FVoxelMaterial Materials[], const float Cache2DValues[], const FVoxelWorldGeneratorQueryZone& QueryZone, const FVoxelPlaceableItemHolder& ItemHolder) const
    {
        FVoxelContext Context(ItemHolder, 0);
        FLocalComputeStruct_LocalMaterialCache2DUsage_LOD0::FVoxelCache Cache;

        float Value = 1;
        FVoxelMaterial Material;
        float CacheValue = 0;
        FLocalComputeStruct_LocalMaterialCache2DUsage_LOD0::FVoxelGraphOutputs GraphOutputs{Material, CacheValue};

        for (int32 X : QueryZone.XIt())
        {
            Context.X = X;

            LocalMaterialCache2DUsage_LOD0.ComputeX(Cache, Context, GraphOutputs);
            for (int32 Y : QueryZone.YIt())
            {
                Context.Y = Y;

                CacheValue = Cache2DValues[QueryZone.GetCache2DIndex(X, Y)];

                LocalMaterialCache2DUsage_LOD0.ComputeXY(Cache, Context, GraphOutputs);
                for (int32 Z : QueryZone.ZIt())
                {
                    Context.Z = Z;

                    Material = FVoxelMaterial();
                    LocalMaterialCache2DUsage_LOD0.ComputeXYZ(Cache, Context, GraphOutputs);
                    SetValueAndMaterial(Values, Materials, QueryZone, 0, ItemHolder, X, Y, Z, Value, Material);
                }
            }
        }
    }
    void GetLocalValueMaterial_LOD0(FVoxelValue Values[], FVoxelMaterial Materials[], const FVoxelWorldGeneratorQueryZone& QueryZone, int32 QueryLOD, const FVoxelPlaceableItemHolder& ItemHolder) const
    {
        FVoxelContext Context(ItemHolder, QueryLOD);
        FLocalComputeStruct_LocalValueMaterial_LOD0::FVoxelCache Cache;

        float Value = 1;
        FVoxelMaterial Material;
        FLocalComputeStruct_LocalValueMaterial_LOD0::FVoxelGraphOutputs GraphOutputs{Value, Material};

        for (int32 X : QueryZone.XIt())
        {
            Context.X = X;

            LocalValueMaterial_LOD0.ComputeX(Cache, Context, GraphOutputs);
            for (int32 Y : QueryZone.YIt())
            {
                Context.Y = Y;

                LocalValueMaterial_LOD0.ComputeXY(Cache, Context, GraphOutputs);
                for (int32 Z : QueryZone.ZIt())
                {
                    Context.Z = Z;

                    Value = 1;
                    Material = FVoxelMaterial();
                    LocalValueMaterial_LOD0.ComputeXYZ(Cache, Context, GraphOutputs);
                    SetValueAndMaterial(Values, Materials, QueryZone, QueryLOD, ItemHolder, X, Y, Z, Value, Material);
                }
            }
        }
    }
    void GetLocalValueMaterialCache2DUsage_LOD0(FVoxelValue Values[], FVoxelMaterial Materials[], const float Cache2DValues[], const FVoxelWorldGeneratorQueryZone& QueryZone, const FVoxelPlaceableItemHolder& ItemHolder) const
    {
        FVoxelContext Context(ItemHolder, 0);
        FLocalComputeStruct_LocalValueMaterialCache2DUsage_LOD0::FVoxelCache Cache;

        float Value = 1;
        FVoxelMaterial Material;
        float CacheValue = 0;
        FLocalComputeStruct_LocalValueMaterialCache2DUsage_LOD0::FVoxelGraphOutputs GraphOutputs{Value, Material, CacheValue};

        for (int32 X : QueryZone.XIt())
        {
            Context.X = X;

            LocalValueMaterialCache2DUsage_LOD0.ComputeX(Cache, Context, GraphOutputs);
            for (int32 Y : QueryZone.YIt())
            {
                Context.Y = Y;

                CacheValue = Cache2DValues[QueryZone.GetCache2DIndex(X, Y)];

                LocalValueMaterialCache2DUsage_LOD0.ComputeXY(Cache, Context, GraphOutputs);
                for (int32 Z : QueryZone.ZIt())
                {
                    Context.Z = Z;

                    Value = 1;
                    Material = FVoxelMaterial();
                    LocalValueMaterialCache2DUsage_LOD0.ComputeXYZ(Cache, Context, GraphOutputs);
                    SetValueAndMaterial(Values, Materials, QueryZone, 0, ItemHolder, X, Y, Z, Value, Material);
                }
            }
        }
    }

private:
    const float Scale;
    const float PlainsNoiseHeight;
    const float RingEdgesHardness;
    const float Width_in_Degrees;
    const float RiverDepth;
    const float Thickness;
    const float BaseHeight;
    const float BaseNoiseHeight;
    const float BaseNoiseFrquency;
    const float MountainsNoiseHeight;
    const float Radius;
    const float RiverWidth;
    const float PlainsNoiseFrequency;
    const float MountainsNoiseFrequency;
    const FRichCurve RingShape;
    const FRichCurve MoutainsMask;
    const FRichCurve RiverMask;
    const FRichCurve PlainsNoiseStrength;
    const FLinearColor PlainsColorLow;
    const FLinearColor RiverColor;
    const FLinearColor BeachColor;
    const FLinearColor MountainsColorHigh;
    const FLinearColor MountainsColorLowLow;
    const FLinearColor MountainsColorLowHigh;
    const FLinearColor PlainsColorHigh;
    const FLinearColor RingOuterColor;
    FLocalComputeStruct_LocalValue_LOD0 LocalValue_LOD0;
    FLocalComputeStruct_LocalMaterial_LOD0 LocalMaterial_LOD0;
    FLocalComputeStruct_LocalValueMaterial_LOD0 LocalValueMaterial_LOD0;
    FLocalComputeStruct_LocalUpVectorXUpVectorYUpVectorZ_LOD0 LocalUpVectorXUpVectorYUpVectorZ_LOD0;
    FLocalComputeStruct_LocalValueRangeAnalysis_LOD0 LocalValueRangeAnalysis_LOD0;
    FLocalComputeStruct_LocalValueCache2DCache_LOD0 LocalValueCache2DCache_LOD0;
    FLocalComputeStruct_LocalValueCache2DUsage_LOD0 LocalValueCache2DUsage_LOD0;
    FLocalComputeStruct_LocalMaterialCache2DUsage_LOD0 LocalMaterialCache2DUsage_LOD0;
    FLocalComputeStruct_LocalValueMaterialCache2DUsage_LOD0 LocalValueMaterialCache2DUsage_LOD0;

};

UCLASS(Blueprintable)
class URingWorld : public UVoxelWorldGenerator
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float Scale = 10.000000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float PlainsNoiseHeight = 250.000000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float RingEdgesHardness = 10.000000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float Width_in_Degrees = 50.000000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float RiverDepth = 100.000000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float Thickness = 500.000000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float BaseHeight = 1000.000000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float BaseNoiseHeight = 250.000000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float BaseNoiseFrquency = 0.005000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float MountainsNoiseHeight = 500.000000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float Radius = 7000.000000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float RiverWidth = 1.000000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float PlainsNoiseFrequency = 0.200000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    float MountainsNoiseFrequency = 0.200000;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    UCurveFloat* RingShape = LoadObject<UCurveFloat>(NULL, TEXT("/Game/RingCurve.RingCurve"));
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    UCurveFloat* MoutainsMask = LoadObject<UCurveFloat>(NULL, TEXT("/Game/MountainsCurve.MountainsCurve"));
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    UCurveFloat* RiverMask = LoadObject<UCurveFloat>(NULL, TEXT("/Game/RiverCurve.RiverCurve"));
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    UCurveFloat* PlainsNoiseStrength = LoadObject<UCurveFloat>(NULL, TEXT("/Game/PlainsNoiseStrengthCurve.PlainsNoiseStrengthCurve"));
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    FLinearColor PlainsColorLow = FLinearColor(0.041351, 0.072917, 0.016724, 1.000000);
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    FLinearColor RiverColor = FLinearColor(0.000000, 0.000000, 1.000000, 1.000000);
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    FLinearColor BeachColor = FLinearColor(0.989583, 0.833626, 0.282215, 1.000000);
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    FLinearColor MountainsColorHigh = FLinearColor(1.000000, 1.000000, 1.000000, 1.000000);
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    FLinearColor MountainsColorLowLow = FLinearColor(0.036458, 0.023406, 0.017120, 1.000000);
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    FLinearColor MountainsColorLowHigh = FLinearColor(0.129469, 0.136312, 0.140625, 1.000000);
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    FLinearColor PlainsColorHigh = FLinearColor(0.104616, 0.184475, 0.042311, 1.000000);
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="")
    FLinearColor RingOuterColor = FLinearColor(0.005208, 0.000000, 0.000099, 1.000000);

    URingWorld() = default;
    TSharedRef<FVoxelWorldGeneratorInstance, ESPMode::ThreadSafe> GetWorldGenerator() override
    {
        return MakeShared<FRingWorldInstance, ESPMode::ThreadSafe>(Scale, PlainsNoiseHeight, RingEdgesHardness, Width_in_Degrees, RiverDepth, Thickness, BaseHeight, BaseNoiseHeight, BaseNoiseFrquency, MountainsNoiseHeight, Radius, RiverWidth, PlainsNoiseFrequency, MountainsNoiseFrequency, (RingShape ? RingShape->FloatCurve : FRichCurve()), (MoutainsMask ? MoutainsMask->FloatCurve : FRichCurve()), (RiverMask ? RiverMask->FloatCurve : FRichCurve()), (PlainsNoiseStrength ? PlainsNoiseStrength->FloatCurve : FRichCurve()), PlainsColorLow, RiverColor, BeachColor, MountainsColorHigh, MountainsColorLowLow, MountainsColorLowHigh, PlainsColorHigh, RingOuterColor);
    }
};