khanat-opennel-code/code/nel/src/misc/noise_value.cpp

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include "stdmisc.h"

#include "nel/misc/noise_value.h"
#include "nel/misc/fast_floor.h"



namespace NLMISC
{


// 3 level: best quality/speed ratio.
#define	NL3D_NOISE_LEVEL			3
#define	NL3D_NOISE_GRID_SIZE_SHIFT	5
#define	NL3D_NOISE_GRID_SIZE		(1<<NL3D_NOISE_GRID_SIZE_SHIFT)
static	const float NL3D_OO255= 1.0f / 255;

// ***************************************************************************
// ***************************************************************************
// ***************************************************************************

// ***************************************************************************
/// A static 3D array of random value + other infos for noise
class	CRandomGrid3D
{
public:

	// generate a random grid, with same seed.
	CRandomGrid3D()
	{
		//seed
		srand(0);

		// init the grid
		for(uint z=0; z<NL3D_NOISE_GRID_SIZE; z++)
		{
			for(uint y=0; y<NL3D_NOISE_GRID_SIZE; y++)
			{
				for(uint x=0; x<NL3D_NOISE_GRID_SIZE; x++)
				{
					uint	id= x + (y<<NL3D_NOISE_GRID_SIZE_SHIFT) + (z<<(NL3D_NOISE_GRID_SIZE_SHIFT*2));
					// take higher bits of rand gives better result.
					uint	v= rand() >> 5;
					_Texture3d[id]= v&255;
				}
			}
		}

		// init sizes.
		uint	i;
		// sum of sizes must be 1, and each level must be /2.
		float	sizeSum=0;
		for(i=0; i<NL3D_NOISE_LEVEL; i++)
		{
			_Sizes[i]= 1.0f / (1<<i);
			sizeSum+= _Sizes[i];
		}
		// normalize
		for(i=0; i<NL3D_NOISE_LEVEL; i++)
		{
			_Sizes[i]/= sizeSum;
		}

		// init LevelPhases.
		for(i=0; i<NL3D_NOISE_LEVEL; i++)
		{
			_LevelPhase[i].x= frand(NL3D_NOISE_GRID_SIZE);
			_LevelPhase[i].y= frand(NL3D_NOISE_GRID_SIZE);
			_LevelPhase[i].z= frand(NL3D_NOISE_GRID_SIZE);
		}
		// not for level 0.
		_LevelPhase[0]= CVector::Null;
	}

	// x/y/z are use to lookup directly in the grid 3D.
	static inline float	evalNearest(const CVector &pos)
	{
		// compute integer part.
		sint	x= OptFastFloor(pos.x);
		sint	y= OptFastFloor(pos.y);
		sint	z= OptFastFloor(pos.z);
		// index in texture.
		uint	ux= x& (NL3D_NOISE_GRID_SIZE-1);
		uint	uy= y& (NL3D_NOISE_GRID_SIZE-1);
		uint	uz= z& (NL3D_NOISE_GRID_SIZE-1);

		// read the texture.
		float	turb= lookup(ux,uy,uz);

		return turb*NL3D_OO255;
	}

	// x/y/z are use to lookup directly in the grid 3D.
	static inline float	evalBiLinear(const CVector &pos)
	{
		// compute integer part.
		sint	x= OptFastFloor(pos.x);
		sint	y= OptFastFloor(pos.y);
		sint	z= OptFastFloor(pos.z);
		// index in texture.
		uint	ux= x& (NL3D_NOISE_GRID_SIZE-1);
		uint	uy= y& (NL3D_NOISE_GRID_SIZE-1);
		uint	uz= z& (NL3D_NOISE_GRID_SIZE-1);
		uint	ux2= (x+1)& (NL3D_NOISE_GRID_SIZE-1);
		uint	uy2= (y+1)& (NL3D_NOISE_GRID_SIZE-1);
		uint	uz2= (z+1)& (NL3D_NOISE_GRID_SIZE-1);
		// delta.
		float	dx2;
		float	dy2;
		float	dz2;
		easeInEaseOut(dx2, pos.x-x);
		easeInEaseOut(dy2, pos.y-y);
		easeInEaseOut(dz2, pos.z-z);
		float	dx= 1-dx2;
		float	dy= 1-dy2;
		float	dz= 1-dz2;
		// TriLinear in texture3D.
		float	turb=0;
		float	dxdy= dx*dy;
		turb+= lookup(ux,uy,uz)* dxdy*dz;
		turb+= lookup(ux,uy,uz2)* dxdy*dz2;
		float	dxdy2= dx*dy2;
		turb+= lookup(ux,uy2,uz)* dxdy2*dz;
		turb+= lookup(ux,uy2,uz2)* dxdy2*dz2;
		float	dx2dy= dx2*dy;
		turb+= lookup(ux2,uy,uz)* dx2dy*dz;
		turb+= lookup(ux2,uy,uz2)* dx2dy*dz2;
		float	dx2dy2= dx2*dy2;
		turb+= lookup(ux2,uy2,uz)* dx2dy2*dz;
		turb+= lookup(ux2,uy2,uz2)* dx2dy2*dz2;

		// End!
		return turb*NL3D_OO255;
	}


	// get size according to level
	static inline float	getLevelSize(uint level)
	{
		return _Sizes[level];
	}

	// get an additional level phase.
	static inline const CVector	&getLevelPhase(uint level)
	{
		return _LevelPhase[level];
	}


// **************
private:

	static	uint8		_Texture3d[NL3D_NOISE_GRID_SIZE*NL3D_NOISE_GRID_SIZE*NL3D_NOISE_GRID_SIZE];
	static	float		_Sizes[NL3D_NOISE_LEVEL];
	static	CVector		_LevelPhase[NL3D_NOISE_LEVEL];


	// lookup with no mod.
	static inline float	lookup(uint ux, uint uy, uint uz)
	{
		uint	id= ux + (uy<<NL3D_NOISE_GRID_SIZE_SHIFT) + (uz<<(NL3D_NOISE_GRID_SIZE_SHIFT*2));
		return	_Texture3d[id];
	}

	// easineasout
	static inline void	easeInEaseOut(float &y, float x)
	{
		// cubic such that f(0)=0, f'(0)=0, f(1)=1, f'(1)=0.
		float	x2=x*x;
		float	x3=x2*x;
		y= -2*x3 + 3*x2;
	}

};


uint8		CRandomGrid3D::_Texture3d[NL3D_NOISE_GRID_SIZE*NL3D_NOISE_GRID_SIZE*NL3D_NOISE_GRID_SIZE];
float		CRandomGrid3D::_Sizes[NL3D_NOISE_LEVEL];
CVector		CRandomGrid3D::_LevelPhase[NL3D_NOISE_LEVEL];

// just to init the static arrays.
static	CRandomGrid3D	NL3D_RandomGrid3D;


// ***************************************************************************
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
float	CNoiseValue::evalRandom(const CVector &pos) const
{
	return CRandomGrid3D::evalNearest(pos);
}


// ***************************************************************************
float	CNoiseValue::noise(const CVector &pos) const
{
	// eval "fractaly".
	float		turb;

#if (NL3D_NOISE_LEVEL != 3)
	CVector		vd= pos;
	turb=0;
	for(uint level=0;level<NL3D_NOISE_LEVEL;level++)
	{
		// Add the influence of the ith level.
		turb+= CRandomGrid3D::getLevelSize(level) *
			CRandomGrid3D::evalBiLinear(vd + CRandomGrid3D::getLevelPhase(level) );
		// Next level at higher frequency
		vd*= 2;
	}
#else
	// special case. unrolled loop.
	// level 0 has no phase.
	turb= CRandomGrid3D::getLevelSize(0) *
		CRandomGrid3D::evalBiLinear(pos);
	// level 1
	turb+= CRandomGrid3D::getLevelSize(1) *
		CRandomGrid3D::evalBiLinear(pos*2 + CRandomGrid3D::getLevelPhase(1) );
	// level 2
	turb+= CRandomGrid3D::getLevelSize(2) *
		CRandomGrid3D::evalBiLinear(pos*4 + CRandomGrid3D::getLevelPhase(2) );
#endif

	return turb;
}



// ***************************************************************************
CNoiseValue::CNoiseValue()
{
	Abs= 0;
	Rand= 1;
	Frequency= 1;
}


// ***************************************************************************
CNoiseValue::CNoiseValue(float abs, float rand, float freq)
{
	Abs= abs;
	Rand= rand;
	Frequency= freq;
}


// ***************************************************************************
float	CNoiseValue::eval(const CVector &posInWorld) const
{
	// A single cube in the Grid3d correspond to Frequency==1.
	// So enlarging size of the grid3d do not affect the frequency aspect.
	return Abs + Rand * noise(posInWorld*Frequency);
}


// ***************************************************************************
float	CNoiseValue::evalOneLevelRandom(const CVector &posInWorld) const
{
	// A single cube in the Grid3d correspond to Frequency==1.
	// So enlarging size of the grid3d do not affect the frequency aspect.
	return Abs + Rand * evalRandom(posInWorld*Frequency);
}


// ***************************************************************************
void	CNoiseValue::serial(IStream &f)
{
	(void)f.serialVersion(0);
	f.serial(Abs);
	f.serial(Rand);
	f.serial(Frequency);
}


// ***************************************************************************
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
void	CNoiseColorGradient::eval(const CVector &posInWorld, CRGBAF &result) const
{
	// test if not null grads.
	uint	nGrads= (uint)Gradients.size();
	if(nGrads==0)
		return;
	// if only one color, easy
	if(nGrads==1)
	{
		result= Gradients[0];
	}
	else
	{
		// eval noise
		float	f= NoiseValue.eval(posInWorld) * (nGrads-1);
		clamp(f, 0.f, (float)(nGrads-1));
		// look up in table of gradients.
		uint	id= OptFastFloor(f);
		clamp(id, 0U, nGrads-2);
		// fractionnal part.
		f= f-id;
		clamp(f, 0, 1);
		// interpolate the gradient.
		result= Gradients[id]*(1-f) + Gradients[id+1]*f;
	}
}

// ***************************************************************************
void	CNoiseColorGradient::serial(IStream &f)
{
	(void)f.serialVersion(0);
	f.serial(NoiseValue);
	f.serialCont(Gradients);
}



} // NLMISC