public override float[,,] getValues(float[,,] values, Noise3D.noiseSumFunction sumFunc, Point3 samples, Vector3 origin, Vector3 area)
{
values = new float[samples.X, samples.Y, samples.Z];
for (int i = 0; i < noises.Count; i++)
{
noises[i].getValues(values, sumFunctions[i], samples, origin, area);
}
Vector3 position = new Vector3();
Vector3 step = new Vector3(area.X / (samples.X - 1), area.Y / (samples.Y - 1), area.Z / (samples.Z - 1));
for (int i = 0; i < values.GetLength(0); i++)
{
for (int j = 0; j < values.GetLength(1); j++)
{
for (int k = 0; k < values.GetLength(2); k++)
{
position.X = i * step.X + origin.X;
position.Y = j * step.Y + origin.Y;
position.Z = k * step.Z + origin.Z;
values[i, j, k] = filter(values[i, j, k], position);
}
}
}
return(values);
}
public static Noise3D RegularNoise(float period, int steps, Point3 periodLoop, int seed)
{
if (steps == 0)
{
throw new Exception("Can't create a noise regular noise with 0 steps");
}
SumNoise3D sumNoise = new SumNoise3D();
Random rdm = new Random(seed);
LoopableNoise3D noise;
float[] weights = new float[steps];
weights[0] = 0.5f;
float weightSum = 0.5f;
for (int i = 1; i < steps; i++)
{
weights[i] = weights[i - 1] * 0.5f;
weightSum += weights[i];
}
//float weight;
Noise3D.noiseSumFunction simpleSum = (float a, float b) => { return(a + b); };
for (int j = 0; j < steps; j++)
{
noise = new LoopableNoise3D(rdm.Next(), period, periodLoop);
float weight = weights[j] / weightSum;
noise.filter = (float value, Vector3 position) => { return(value * (weight)); };
sumNoise.addNoise(noise, simpleSum);
period *= 0.5f;
periodLoop.X *= 2;
periodLoop.Y *= 2;
periodLoop.Z *= 2;
}
return(sumNoise);
}
public override float[,,] getValues(float[,,] values, Noise3D.noiseSumFunction sumFunc, Point3 samples, Vector3 origin, Vector3 area)
{
origin *= 1f / period;
area *= 1f / period;
float difX, difY, difZ;
Vector3 difVector = new Vector3();
Vector3 step = new Vector3(area.X / (samples.X - 1), area.Y / (samples.Y - 1), area.Z / (samples.Z - 1));
Vector3 pos = new Vector3();
int cubeX, cubeY, cubeZ;
Vector3 gradientVector;
float lll, llu, lul, luu, ull, ulu, uul, uuu;
float ll, lu, ul, uu;
float l, u;
float value;
for (int i = 0; i < samples.X; i++)
{
for (int j = 0; j < samples.Y; j++)
{
for (int k = 0; k < samples.Z; k++)
{
pos.X = origin.X + i * step.X;
pos.Y = origin.Y + j * step.Y;
pos.Z = origin.Z + k * step.Z;
cubeX = (int)Math.Floor(pos.X);
cubeY = (int)Math.Floor(pos.Y);
cubeZ = (int)Math.Floor(pos.Z);
difX = pos.X - (float)cubeX;
difY = pos.Y - (float)cubeY;
difZ = pos.Z - (float)cubeZ;
pos *= period;
//lll llu luu lul uul uuu ulu ull
//lll
difVector.X = difX;
difVector.Y = difY;
difVector.Z = difZ;
gradientVector = getGradientVector(cubeX, cubeY, cubeZ);
Vector3.Dot(ref gradientVector, ref difVector, out lll);
//llu
difVector.Z = difZ - 1f;
gradientVector = getGradientVector(cubeX, cubeY, cubeZ + 1);
Vector3.Dot(ref gradientVector, ref difVector, out llu);
//luu
difVector.Y = difY - 1f;
gradientVector = getGradientVector(cubeX, cubeY + 1, cubeZ + 1);
Vector3.Dot(ref gradientVector, ref difVector, out luu);
//lul
difVector.Z = difZ;
gradientVector = getGradientVector(cubeX, cubeY + 1, cubeZ);
Vector3.Dot(ref gradientVector, ref difVector, out lul);
//uul
difVector.X = difX - 1f;
gradientVector = getGradientVector(cubeX + 1, cubeY + 1, cubeZ);
Vector3.Dot(ref gradientVector, ref difVector, out uul);
//uuu
difVector.Z = difZ - 1f;
gradientVector = getGradientVector(cubeX + 1, cubeY + 1, cubeZ + 1);
Vector3.Dot(ref gradientVector, ref difVector, out uuu);
//ulu
difVector.Y = difY;
gradientVector = getGradientVector(cubeX + 1, cubeY, cubeZ + 1);
Vector3.Dot(ref gradientVector, ref difVector, out ulu);
//ull
difVector.Z = difZ;
gradientVector = getGradientVector(cubeX + 1, cubeY, cubeZ);
Vector3.Dot(ref gradientVector, ref difVector, out ull);
ll = NGInterp(lll, ull, difX);
lu = NGInterp(llu, ulu, difX);
ul = NGInterp(lul, uul, difX);
uu = NGInterp(luu, uuu, difX);
l = NGInterp(ll, ul, difY);
u = NGInterp(lu, uu, difY);
value = NGInterp(l, u, difZ);
value = (float)Math.Cos((value + 1) * Math.PI / 2);
values[i, j, k] = sumFunc(values[i, j, k], filter(value, pos));
}
}
}
return(values);
}
