Getting top layer of 3d noise

Question

I've generated a cubic world using FastNoiseLite but I don't know how to differentiate top level blocks as grass and bottom one's dirt when using 3d noise.

TArray<float> CalculateNoise(const FVector& ChunkPosition)
{
    Densities.Reset();

    // ChunkSize is 32
    for (int z = 0; z < ChunkSize; z++)
    {
        for (int y = 0; y < ChunkSize; y++)
        {
            for (int x = 0; x < ChunkSize; x++)
            {
                const float Noise = GetNoise(FVector(ChunkPosition.X + x, ChunkPosition.Y + y, ChunkPosition.Z + z));
                Densities.Add(Noise - ChunkPosition.Z);
            }
        }
    }

    return Densities;
}

void AddCubeMaterial(const FVector& ChunkPosition)
{
    const int32 DensityIndex = GetIndex(ChunkPosition);
    const float Density = Densities[DensityIndex];

    if (Density < 1)
    {
        // Add Grass block
    }

    // Add dirt block
}

void GetNoise(const FVector& Position) const
{
    const float Height = 280.f;
    if (bIs3dNoise)
    {
        FastNoiseLiteObj->GetNoise(Position.X, Position.Y, Position.Z) * Height;
    }
    
    FastNoiseLiteObj->GetNoise(Position.X, Position.Y) * Height;
}

This is the result when using 3D noise.

3D Noise result

But if I switch to 2D noise it works perfectly fine.

2D Noise result

Answer 1

This answer applies to Perlin like noise.

Your integer chunk size is dis-contiguous in noise space.

'Position' needs to be scaled by 1/Height. To scale the noise as a contiguous block. Then scale by Height.

---

If you were happy with the XY axes(2D), you could limit the scaling to the Z axis:

FastNoiseLiteObj->GetNoise(Position.X, Position.Y, Position.Z / Height) * Height;    

This adjustment provides a noise continuous Z block location with respect to Position(X,Y).

Edit in response to comments

Contiguous: The noise algorithm guarantees continuous output in all dimensions.

By sampling every 32 pixels (dis-contiguous sampling), The continuity is broken, on purpose(?) and augmented by the Density.

To guarantee a top level grass layer:

Densities.Add(Noise + (ChunkPosition.Z > Threshold) ? 1: 0); Your code- ChunkPosition.Z made grass thicker as it went down. Add it back if you wish.

To add random overhangs/underhangs reduce the Density threshold randomly: if (Density < (rnd() < 0.125)? 0.5 : 1) I leave the definition of rnd() to your preferred random distribution.

To almost always have overhangs, requires forward lookup of the next and previous blocks' Z in noise.

Precalculate the noise values for the next line into alternating arrays 2 wider than the width to support the edges set at 0.

The algorithm is:

// declare  arrays: currentnoise[ChunkSize + 2] and nextnoise[ChunkSize +2] and alpha=.2; //see text
    for (int y = 0; y < ChunkSize; y++) // note the reorder y-z-x
    {
        // pre load currentnoise for z=0
        currentnoise[0] = 0;
        currentnoise[ChunkSize+1] = 0;
        for (int x = 0; x < ChunkSize; x++)
        {
             currentnoise[x + 1] = GetNoise(FVector(ChunkPosition.X + x, ChunkPosition.Y + y, ChunkPosition.Z));
        }
        for (int z = 1; z < ChunkSize -2; z++)
        {
            nextnoise[0] = 0;
            nextnoise[ChunkSize+1] = 0;
            // load next
            for (int x = 0; x < ChunkSize; x++)
            {
                nextnoise[x + 1] = GetNoise(FVector(ChunkPosition.X + x, ChunkPosition.Y + y, ChunkPosition.Z + z+1));
            }
            // apply current with next
            for (int x = 0; x < ChunkSize; x++)
            {
                Densities.Add(currentnoise[x + 1] * .75 + nextnoise[x+2] * alpha + nextnoise[x] * alpha);
            }
            
           // move next to current in a memory safe manor:
           // it is faster to swap pointers, but this is much safer for portability
           for (int i = 1; i < ChunkSize + 1; i++)
               currentnoise[i]=nextnoise[i];
        }
        // apply last z(no next)
        for (int x = 0; x < ChunkSize; x++)
        {
            Densities.Add(currentnoise[X + 1]);
        }
    }

Where alpha is approximately between .025 and .25 depending on preferred fill amounts.

The 2 inner most x for loops could be streamlined into 1 loop, but left separate for readability.(it requires 2 preloads)