private void PositionParticles()
{
Quaternion q = Quaternion.Euler(surface.rotation);
Quaternion qInv = Quaternion.Inverse(q);
NoiseMethod method = Noise.methods[(int)surface.type][surface.dimensions - 1];
float amplitude = surface.damping ? surface.strength / surface.frequency : surface.strength;
for (int i = 0; i < particles.Length; i++)
{
Vector3 position = particles[i].position;
Vector3 point = q * new Vector3(position.x, position.z) + surface.offset;
NoiseSample sample = Noise.Sum(method, point, surface.frequency, surface.octaves, surface.lacunarity, surface.persistence);
sample = sample * 0.5f;
sample *= amplitude;
sample.derivative = qInv * sample.derivative;
Vector3 curl = new Vector3(sample.derivative.y, 0f, -sample.derivative.x);
position += curl * Time.deltaTime * flowStrength;
position.y = sample.value + system.startSize;
particles[i].position = position;
if (position.x < -0.5f || position.x > 0.5f || position.z < -0.5f || position.z > 0.5f)
{
particles[i].remainingLifetime = 0f;
}
}
}
public static NoiseSample Simplex3D(Vector3 point, float frequency)
{
point *= frequency;
float skew = (point.x + point.y + point.z) * (1f / 3f);
float sx = point.x + skew;
float sy = point.y + skew;
float sz = point.z + skew;
int ix = Mathf.FloorToInt(sx);
int iy = Mathf.FloorToInt(sy);
int iz = Mathf.FloorToInt(sz);
NoiseSample sample = Simplex3DPart(point, ix, iy, iz);
sample += Simplex3DPart(point, ix + 1, iy + 1, iz + 1);
float x = sx - ix;
float y = sy - iy;
float z = sz - iz;
if (x >= y)
{
if (x >= z)
{
sample += Simplex3DPart(point, ix + 1, iy, iz);
if (y >= z)
{
sample += Simplex3DPart(point, ix + 1, iy + 1, iz);
}
else
{
sample += Simplex3DPart(point, ix + 1, iy, iz + 1);
}
}
else
{
sample += Simplex3DPart(point, ix, iy, iz + 1);
sample += Simplex3DPart(point, ix + 1, iy, iz + 1);
}
}
else
{
if (y >= z)
{
sample += Simplex3DPart(point, ix, iy + 1, iz);
if (x >= z)
{
sample += Simplex3DPart(point, ix + 1, iy + 1, iz);
}
else
{
sample += Simplex3DPart(point, ix, iy + 1, iz + 1);
}
}
else
{
sample += Simplex3DPart(point, ix, iy, iz + 1);
sample += Simplex3DPart(point, ix, iy + 1, iz + 1);
}
}
sample.derivative *= frequency;
return(sample * simplexScale3D);
}
public static NoiseSample Simplex1D(Vector3 point, float frequency)
{
point *= frequency;
int ix = Mathf.FloorToInt(point.x);
NoiseSample sample = Simplex1DPart(point, ix);
sample += Simplex1DPart(point, ix + 1);
sample.derivative *= frequency;
return(sample * (64f / 27f));
}
public static NoiseSample SimplexValue1D(Vector3 point, float frequency)
{
point *= frequency;
int ix = Mathf.FloorToInt(point.x);
NoiseSample sample = SimplexValue1DPart(point, ix);
sample += SimplexValue1DPart(point, ix + 1);
sample.derivative *= frequency;
return(sample * (2f / hashMask) - 1f);
}
public void Refresh()
{
if (resolution != currentResolution)
{
CreateGrid();
}
Quaternion q = Quaternion.Euler(rotation);
Quaternion qInv = Quaternion.Inverse(q);
Vector3 point00 = q * new Vector3(-0.5f, -0.5f) + offset;
Vector3 point10 = q * new Vector3(0.5f, -0.5f) + offset;
Vector3 point01 = q * new Vector3(-0.5f, 0.5f) + offset;
Vector3 point11 = q * new Vector3(0.5f, 0.5f) + offset;
NoiseMethod method = Noise.methods[(int)type][dimensions - 1];
float stepSize = 1f / resolution;
float amplitude = damping ? strength / frequency : strength;
for (int v = 0, y = 0; y <= resolution; y++)
{
Vector3 point0 = Vector3.Lerp(point00, point01, y * stepSize);
Vector3 point1 = Vector3.Lerp(point10, point11, y * stepSize);
for (int x = 0; x <= resolution; x++, v++)
{
Vector3 point = Vector3.Lerp(point0, point1, x * stepSize);
NoiseSample sample = Noise.Sum(method, point, frequency, octaves, lacunarity, persistence);
sample = sample * 0.5f;
if (coloringForStrength)
{
colors[v] = coloring.Evaluate(sample.value + 0.5f);
sample *= amplitude;
}
else
{
sample *= amplitude;
colors[v] = coloring.Evaluate(sample.value + 0.5f);
}
vertices[v].y = sample.value;
sample.derivative = qInv * sample.derivative;
if (analyticalDerivatives)
{
normals[v] = new Vector3(-sample.derivative.x, 1f, -sample.derivative.y).normalized;
}
}
}
mesh.vertices = vertices;
mesh.colors = colors;
if (!analyticalDerivatives)
{
CalculateNormals();
}
mesh.normals = normals;
}
private static NoiseSample SimplexValue1DPart(Vector3 point, int ix)
{
float x = point.x - ix;
float f = 1f - x * x;
float f2 = f * f;
float f3 = f * f2;
float h = hash[ix & hashMask];
NoiseSample sample = new NoiseSample();
sample.value = h * f3;
sample.derivative.x = -6f * h * x * f2;
return(sample);
}
private static NoiseSample Simplex1DPart(Vector3 point, int ix)
{
float x = point.x - ix;
float f = 1f - x * x;
float f2 = f * f;
float f3 = f * f2;
float g = gradients1D[hash[ix & hashMask] & gradientsMask1D];
float v = g * x;
NoiseSample sample = new NoiseSample();
sample.value = v * f3;
sample.derivative.x = g * f3 - 6f * v * x * f2;
return(sample);
}
public static NoiseSample Sum(NoiseMethod method, Vector3 point, float frequency, int octaves, float lacunarity, float persistence)
{
NoiseSample sum = method(point, frequency);
float amplitude = 1f;
float range = 1f;
for (int o = 1; o < octaves; o++)
{
frequency *= lacunarity;
amplitude *= persistence;
range += amplitude;
sum += method(point, frequency) * amplitude;
}
return(sum * (1f / range));
}
private static NoiseSample SimplexValue2DPart(Vector3 point, int ix, int iy)
{
float unskew = (ix + iy) * squaresToTriangles;
float x = point.x - ix + unskew;
float y = point.y - iy + unskew;
float f = 0.5f - x * x - y * y;
NoiseSample sample = new NoiseSample();
if (f > 0f)
{
float f2 = f * f;
float f3 = f * f2;
float h = hash[hash[ix & hashMask] + iy & hashMask];
float h6f2 = -6f * h * f2;
sample.value = h * f3;
sample.derivative.x = h6f2 * x;
sample.derivative.y = h6f2 * y;
}
return(sample);
}
private static NoiseSample Simplex2DPart(Vector3 point, int ix, int iy)
{
float unskew = (ix + iy) * squaresToTriangles;
float x = point.x - ix + unskew;
float y = point.y - iy + unskew;
float f = 0.5f - x * x - y * y;
NoiseSample sample = new NoiseSample();
if (f > 0f)
{
float f2 = f * f;
float f3 = f * f2;
Vector2 g = gradients2D[hash[hash[ix & hashMask] + iy & hashMask] & gradientsMask2D];
float v = Dot(g, x, y);
float v6f2 = -6f * v * f2;
sample.value = v * f3;
sample.derivative.x = g.x * f3 + v6f2 * x;
sample.derivative.y = g.y * f3 + v6f2 * y;
}
return(sample);
}
public static NoiseSample Simplex2D(Vector3 point, float frequency)
{
point *= frequency;
float skew = (point.x + point.y) * trianglesToSquares;
float sx = point.x + skew;
float sy = point.y + skew;
int ix = Mathf.FloorToInt(sx);
int iy = Mathf.FloorToInt(sy);
NoiseSample sample = Simplex2DPart(point, ix, iy);
sample += Simplex2DPart(point, ix + 1, iy + 1);
if (sx - ix >= sy - iy)
{
sample += Simplex2DPart(point, ix + 1, iy);
}
else
{
sample += Simplex2DPart(point, ix, iy + 1);
}
sample.derivative *= frequency;
return(sample * simplexScale2D);
}
private static NoiseSample SimplexValue3DPart(Vector3 point, int ix, int iy, int iz)
{
float unskew = (ix + iy + iz) * (1f / 6f);
float x = point.x - ix + unskew;
float y = point.y - iy + unskew;
float z = point.z - iz + unskew;
float f = 0.5f - x * x - y * y - z * z;
NoiseSample sample = new NoiseSample();
if (f > 0f)
{
float f2 = f * f;
float f3 = f * f2;
float h = hash[hash[hash[ix & hashMask] + iy & hashMask] + iz & hashMask];
float h6f2 = -6f * h * f2;
sample.value = h * f3;
sample.derivative.x = h6f2 * x;
sample.derivative.y = h6f2 * y;
sample.derivative.z = h6f2 * z;
}
return(sample);
}
private static NoiseSample Simplex3DPart(Vector3 point, int ix, int iy, int iz)
{
float unskew = (ix + iy + iz) * (1f / 6f);
float x = point.x - ix + unskew;
float y = point.y - iy + unskew;
float z = point.z - iz + unskew;
float f = 0.5f - x * x - y * y - z * z;
NoiseSample sample = new NoiseSample();
if (f > 0f)
{
float f2 = f * f;
float f3 = f * f2;
Vector3 g = simplexGradients3D[hash[hash[hash[ix & hashMask] + iy & hashMask] + iz & hashMask] & simplexGradientsMask3D];
float v = Dot(g, x, y, z);
float v6f2 = -6f * v * f2;
sample.value = v * f3;
sample.derivative.x = g.x * f3 + v6f2 * x;
sample.derivative.y = g.y * f3 + v6f2 * y;
sample.derivative.z = g.z * f3 + v6f2 * z;
}
return(sample);
}
private void PositionParticles()
{
Quaternion q = Quaternion.Euler(rotation);
Quaternion qInv = Quaternion.Inverse(q);
NoiseMethod method = Noise.methods[(int)type][dimensions - 1];
float amplitude = damping ? strength / frequency : strength;
morphOffset += Time.deltaTime * morphSpeed;
if (morphOffset > 256f)
{
morphOffset -= 256f;
}
for (int i = 0; i < particles.Length; i++)
{
Vector3 position = particles[i].position;
Vector3 point = q * new Vector3(position.z, position.y, position.x + morphOffset) + offset;
NoiseSample sampleX = Noise.Sum(method, point, frequency, octaves, lacunarity, persistence);
sampleX *= amplitude;
sampleX.derivative = qInv * sampleX.derivative;
point = q * new Vector3(position.x + 100f, position.z, position.y + morphOffset) + offset;
NoiseSample sampleY = Noise.Sum(method, point, frequency, octaves, lacunarity, persistence);
sampleY *= amplitude;
sampleY.derivative = qInv * sampleY.derivative;
point = q * new Vector3(position.y, position.x + 100f, position.z + morphOffset) + offset;
NoiseSample sampleZ = Noise.Sum(method, point, frequency, octaves, lacunarity, persistence);
sampleZ *= amplitude;
sampleZ.derivative = qInv * sampleZ.derivative;
Vector3 curl;
curl.x = sampleZ.derivative.x - sampleY.derivative.y;
curl.y = sampleX.derivative.x - sampleZ.derivative.y + (1f / (1f + position.y));
curl.z = sampleY.derivative.x - sampleX.derivative.y;
particles[i].velocity = curl;
}
}
