public float GetPointX(int pointIndexX, int pointIndexZ, float scale, float jitter)
{
float noiseX = FlickNoise.SimplexValue2D(pointIndexX, pointIndexZ);
float pointXOffset = noiseX * scale * jitter;
return(pointIndexX * scale + pointXOffset);
}
public float GetPointZ(int pointIndexX, int pointIndexZ, float scale, float jitter)
{
float noiseZ = FlickNoise.SimplexValue2D(pointIndexX + 1, pointIndexZ + 1);
float pointZOffset = noiseZ * scale * jitter;
return(pointIndexZ * scale + pointZOffset);
}
public override float GetNumber(OutputSocket outSocket, Request request)
{
float scale = GetInputNumber(_inputSocketScale, request);
float inputSeed = GetInputNumber(_inputSocketSeed, request);
if (float.IsNaN(scale) || float.IsNaN(inputSeed))
{
return(float.NaN);
}
float s = NodeUtils.ModifySeed(request.Seed, inputSeed);
float x = request.X + s;
float y = request.Y + s;
float z = request.Z + s;
if (_selectedNoiseType == 0)
{
if (_selectedDimension == 0)
{
return(FlickNoise.Value1D(x / scale, true));
}
if (_selectedDimension == 1)
{
return(FlickNoise.Value2D(x / scale, z / scale, true));
}
if (_selectedDimension == 2)
{
return(FlickNoise.Value3D(x / scale, z / scale, y / scale, true));
}
}
if (_selectedNoiseType == 1)
{
if (_selectedDimension == 0)
{
return(FlickNoise.Perlin1D(x / scale, true));
}
if (_selectedDimension == 1)
{
return(FlickNoise.Perlin2D(x / scale, z / scale, true));
}
if (_selectedDimension == 2)
{
return(FlickNoise.Perlin3D(x / scale, z / scale, y / scale, true));
}
}
if (_selectedNoiseType == 2)
{
if (_selectedDimension == 0)
{
return(FlickNoise.SimplexValue1D(x / scale));
}
if (_selectedDimension == 1)
{
return(FlickNoise.SimplexValue2D(x / scale, z / scale));
}
if (_selectedDimension == 2)
{
return(FlickNoise.SimplexValue3D(x / scale, z / scale, y / scale));
}
}
if (_selectedNoiseType == 3)
{
if (_selectedDimension == 0)
{
return(FlickNoise.Simplex1D(x / scale));
}
if (_selectedDimension == 1)
{
return(FlickNoise.Simplex2D(x / scale, z / scale));
}
}
return(float.NaN);
}
public override float GetNumber(OutputSocket outSocket, Request request)
{
float scale = GetInputNumber(_inputSocketScale, request);
float jitter = GetInputNumber(_inputSocketJitter, request);
float internalSeed = GetInputNumber(_inputSocketSeed, request);
jitter = Mathf.Max(0, Mathf.Min(jitter, 1));
if (float.IsNaN(scale) || float.IsNaN(internalSeed) || scale == 0)
{
return(float.NaN);
}
int pointX = Mathf.RoundToInt(request.X / scale);
int pointZ = Mathf.RoundToInt(request.Z / scale);
float d1 = GetDistanceToPoint(pointX + _px[0], pointZ + _pz[0], request.X, request.Z, scale, jitter);
float d2 = GetDistanceToPoint(pointX + _px[1], pointZ + _pz[1], request.X, request.Z, scale, jitter);
float d3 = GetDistanceToPoint(pointX + _px[2], pointZ + _pz[2], request.X, request.Z, scale, jitter);
float d4 = GetDistanceToPoint(pointX + _px[3], pointZ + _pz[3], request.X, request.Z, scale, jitter);
float d5 = GetDistanceToPoint(pointX + _px[4], pointZ + _pz[4], request.X, request.Z, scale, jitter);
float d6 = GetDistanceToPoint(pointX + _px[5], pointZ + _pz[5], request.X, request.Z, scale, jitter);
float d7 = GetDistanceToPoint(pointX + _px[6], pointZ + _pz[6], request.X, request.Z, scale, jitter);
float d8 = GetDistanceToPoint(pointX + _px[7], pointZ + _pz[7], request.X, request.Z, scale, jitter);
float d9 = GetDistanceToPoint(pointX + _px[8], pointZ + _pz[8], request.X, request.Z, scale, jitter);
int firstLowestIndex = GetLowestDistanceIndex(d1, d2, d3, d4, d5, d6, d7, d8, d9);
if (_selectedDistanceType == 2)
{
// voronoi
float firstLowestPointY = FlickNoise.SimplexValue2D(pointX + _px[firstLowestIndex], pointZ + _pz[firstLowestIndex]);
return(firstLowestPointY);
}
float firstLowestDistance = GetValue(firstLowestIndex, d1, d2, d3, d4, d5, d6, d7, d8, d9);
if (_selectedDistanceIndex == 0)
{
// first
return(Norm(firstLowestDistance));
}
int secondLowestIndex = GetSecondLowestDistanceIndex(firstLowestIndex, d1, d2, d3, d4, d5, d6, d7, d8, d9);
float secondLowestDistance = GetValue(secondLowestIndex, d1, d2, d3, d4, d5, d6, d7, d8, d9);
if (_selectedDistanceIndex == 1)
{
// second
return(Norm(secondLowestDistance));
}
float sf = secondLowestDistance - firstLowestDistance;
if (_selectedDistanceIndex == 2)
{
return(Norm(sf));
}
if (_selectedDistanceIndex == 3)
{
// Min(second - first);
return(Norm(Mathf.Min(sf, Mathf.Min(secondLowestDistance, firstLowestDistance))));
}
return(Norm(firstLowestDistance));
}
