// VALUE // public static NoiseSample Value1D(Vector3 point, float frequency, bool derivative) { point *= frequency; int i0 = Mathf.FloorToInt(point.x); i0 &= hashMask; int i1 = i0 + 1; int h0 = GameUtils.Hash[i0]; int h1 = GameUtils.Hash[i1]; float a = h0; float b = h1 - h0; float t = point.x - i0; float ts = GameUtils.Smooth(t); NoiseSample sample = new NoiseSample(); sample.value = a + b * ts; if (derivative) { float dt = GameUtils.SmoothDerivative(t); sample.derivative.x = b * dt; sample.derivative.y = 0f; sample.derivative.z = 0f; sample.derivative *= frequency; } return(sample * (2f / hashMask) - 1f); }
private void FillTexture() { NoiseMethod method = Noise.noiseMethods[(int)type][dimensions - 1]; float stepSize = 1f / resolution; Vector3 point00 = transform.TransformPoint(new Vector3(-0.5f, -0.5f)); Vector3 point10 = transform.TransformPoint(new Vector3(0.5f, -0.5f)); Vector3 point01 = transform.TransformPoint(new Vector3(-0.5f, 0.5f)); Vector3 point11 = transform.TransformPoint(new Vector3(0.5f, 0.5f)); for (int y = 0; y < resolution; y++) { Vector3 point0 = Vector3.Lerp(point00, point01, (y + 0.5f) * stepSize); Vector3 point1 = Vector3.Lerp(point10, point11, (y + 0.5f) * stepSize); for (int x = 0; x < resolution; x++) { Vector3 point = Vector3.Lerp(point0, point1, (x + 0.5f) * stepSize); NoiseSample sample = Noise.Sum(method, point, frequency, octaves, lacunarity, persistence); sample = sample * 0.5f + 0.5f; texture.SetPixel(x, y, Color.white * coloring.Evaluate(sample.value)); } } texture.Apply(); }
public NoiseSample[,] CreateNoise(Vector2 location, Vector2Int size, int chunkSize, int seed) { danny.Begin(); // create a item to return NoiseSample[,] NoiseMap = new NoiseSample[size.x, size.y]; // generate map heights with octaves each octave being more imporatant in generation than last for (int X = 0; X < NoiseMap.GetLength(0); X++) { for (int Z = 0; Z < NoiseMap.GetLength(1); Z++) { Vector3 pos = (Vector3)((new Vector2(X - 1, Z - 1) + location * 240f) / 240f); NoiseSample height = Desert(pos); NoiseMap[X, Z] = height; } } danny.End(); return(NoiseMap); }
public void Refresh() { if (resolution != currentResolution) { CreateGrid(); } Quaternion q = Quaternion.Euler(rotation); 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.noiseMethods[(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 = type == NoiseMethodType.Value ? (sample - 0.5f) : (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 *= strength; if (type != NoiseMethodType.Value) { sample = sample * 0.5f + 0.5f; } vertices[v].y = sample.value; // colors[v] = coloring.Evaluate(sample + 0.5f); } } mesh.vertices = vertices; mesh.colors = colors; CalculateNormals(); mesh.normals = normals; }
private static NoiseSample SimplexValue2DPart(Vector3 point, int ix, int iy, bool derivative) { 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 = GameUtils.Hash[GameUtils.Hash[ix & hashMask] + iy & hashMask]; sample.value = h * f3; if (derivative) { float h6f2 = -6f * h * f2; sample.derivative.x = h6f2 * x; sample.derivative.y = h6f2 * y; } } 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; curl.z = sampleY.derivative.x - sampleX.derivative.y; particles[i].velocity = curl; } }
public override NoiseSample interpolate(float x, float y, float z) { NoiseMethod method = Noise.methods[(int)NoiseMethodType.Simplex][2]; NoiseSample sample = Noise.Sum(method, new Vector3(x, y, z), 1, 2, 2, .5f); return(sample); }
private static NoiseSample Simplex3DPart(Vector3 point, int ix, int iy, int iz, bool derivative) { 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[GameUtils.Hash[GameUtils.Hash[GameUtils.Hash[ix & hashMask] + iy & hashMask] + iz & hashMask] & simplexGradientsMask3D]; float v = GameUtils.Dot(g, x, y, z); sample.value = v * f3; if (derivative) { float v6f2 = -6f * v * f2; sample.derivative.x = g.x * f3 + v6f2 * x; sample.derivative.y = g.y * f3 + v6f2 * y; sample.derivative.z = g.z * f3 + v6f2 * z; } else { sample.derivative = Vector3.zero; } } return(sample); }
private static NoiseSample Simplex2DPart(Vector3 point, int ix, int iy, bool derivative) { 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[GameUtils.Hash[GameUtils.Hash[ix & hashMask] + iy & hashMask] & gradientsMask2D]; float v = GameUtils.Dot(g, x, y); float v6f2 = -6f * v * f2; sample.value = v * f3; if (derivative) { sample.derivative.x = g.x * f3 + v6f2 * x; sample.derivative.y = g.y * f3 + v6f2 * y; } else { sample.derivative = Vector3.zero; } } return(sample); }
public static NoiseSample SimplexGradient2D(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 = SimplexGradient2DPart(point, ix, iy); sample += SimplexGradient2DPart(point, ix + 1, iy + 1); if (sx - ix >= sy - iy) { sample += SimplexGradient2DPart(point, ix + 1, iy); } else { sample += SimplexGradient2DPart(point, ix, iy + 1); } return(sample * simplexScale2D); }
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); }
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.main.startSize.constant; 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 SimplexValue2D(Vector3 point, float frequency, bool derivative) { 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 = SimplexValue2DPart(point, ix, iy, derivative); sample += SimplexValue2DPart(point, ix + 1, iy + 1, derivative); if (sx - ix >= sy - iy) { sample += SimplexValue2DPart(point, ix + 1, iy, derivative); } else { sample += SimplexValue2DPart(point, ix, iy + 1, derivative); } if (derivative) { sample.derivative *= frequency; } return(sample * (8f * 2f / hashMask) - 1f); }
private static NoiseSample SimplexValue3DPart(Vector3 point, int ix, int iy, int iz, bool derivative) { 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 = GameUtils.Hash[GameUtils.Hash[GameUtils.Hash[ix & hashMask] + iy & hashMask] + iz & hashMask]; sample.value = h * f3; if (derivative) { float h6f2 = -6f * h * f2; sample.derivative.x = h6f2 * x; sample.derivative.y = h6f2 * y; sample.derivative.z = h6f2 * z; } else { sample.derivative = Vector3.zero; } } return(sample); }
public void Refresh() { if (mesh == null) { Init(); } 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 = type == NoiseMethodType.Value ? (sample - 0.5f) : (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; }
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 Simplex1D(Vector3 point, float frequency) { point *= frequency; int ix = Mathf.FloorToInt(point.x); // get left-side cell start position NoiseSample sample = Simplex1DPart(point, ix); // get falloff value of this point from left cell int position sample += Simplex1DPart(point, ix + 1); // get and add falloff value of this point from right cell int position sample.derivative *= frequency; return(sample * (64f / 27f)); // get value back into 0-1 range }
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; NoiseMethod2 method = Noise2.noiseMethods[(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 = Noise2.Sum(method, point, frequency, octaves, lacunarity, persistence); sample = type == NoiseMethodType2.Value ? (sample - 0.5f) : (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) { //calcualtes the analytical normals _normals[v] = new Vector3(-sample.derivative.x, 1f, -sample.derivative.y).normalized; } } } _mesh.vertices = _vertices; _mesh.colors = _colors; //_mesh.RecalculateNormals(); if (!analyticalDerivatives) { CalculateNormals(); //a version of the above RecalculateNormals() method } _mesh.normals = _normals; }
// catlikecoding Noise public static float[,] theCatNoise(int mapWidth, int mapHeight, float resolution, int octaves, float persistence, float lacunarity, bool damping, float strength) { float frequency = 1f; Vector3 offset = new Vector3(1f, 2f, 3f); Vector3 rotation = new Vector3(45f, 45f, 0f); float [,] noiseMap = new float[mapWidth, mapHeight]; 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 / mapHeight; float amplitude = damping ? strength / frequency : strength; for (int v = 0, y = 0; y < mapWidth; y++) { Vector3 point0 = Vector3.Lerp(point00, point01, y * stepSize); Vector3 point1 = Vector3.Lerp(point10, point11, y * stepSize); for (int x = 0; x < mapHeight; x++, v++) { Vector3 point = Vector3.Lerp(point0, point1, x * stepSize); NoiseSample sample = catNoise.Sum3D(point, frequency, octaves, lacunarity, persistence); sample = sample - 0.5f; sample *= amplitude; // sample = type == NoiseMethodType.Value ? (sample - 0.5f) : (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 = 1f-Mathf.Abs(sample.value); //sample.derivative = qInv * sample.derivative; // if (analyticalDerivatives) { // normals[v] = new Vector3(-sample.derivative.x, 1f, -sample.derivative.y).normalized; // } noiseMap[y, x] = sample.value; } } // Ridged // sample.value = 1f-Mathf.Abs(sample.value); // sample.derivative = qInv * sample.derivative; return(noiseMap); }
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); }
// ------------------------- // // SIMPLEX VALUE NOISE FUNCTIONS: // // ======================================================================================================== private static NoiseSample SimplexValue1DPart(Vector3 point, int ix) { float x = point.x - ix; // get relative position of sample point with respect to base integer cell float f = 1f - x * x; float f2 = f * f; float f3 = f * f2; // falloff function f(0)=1, f(1)=0 float h = hash [ix & hashMask]; // get hashed (shuffled) value for this cell int NoiseSample sample = new NoiseSample(); sample.value = h * f3; // multiply h hash value by f3, the contribution of h at this position. sample.derivative.x = -6f * h * x * f2; return(sample); }
private void UpdateSkyTangents() { for (int i = 0; i < strokeBackgroundArray.Length; i++) { //background1[i].y = Mathf.Abs(background1[i].y); NoiseSample noiseSample = NoisePrime.Simplex3D(strokeBackgroundArray[i].pos + skyNoiseOffset, skyNoiseFrequency); //float size = Vector3.Dot(noiseSample.derivative.normalized, strokeBackgroundArray[i].normal); noiseSample.value = noiseSample.value * 0.5f + 0.5f; //strokeBackgroundArray[i].pos = background1[i]; float colorNoiseFrequency = 1000f; NoiseSample colorNoiseSample = NoisePrime.Simplex3D(strokeBackgroundArray[i].pos, skyNoiseFrequency * colorNoiseFrequency); float colorNoise = (colorNoiseSample.value * 0.5f + 0.5f); Color color = skyColorGradient.Evaluate(Vector3.Dot(strokeBackgroundArray[i].pos.normalized, Vector3.up)); strokeBackgroundArray[i].col = new Vector3(Mathf.Lerp(color.r, colorNoise, skyColorNoise), Mathf.Lerp(color.g, colorNoise, skyColorNoise), Mathf.Lerp(color.b, colorNoise, skyColorNoise)); //strokeBackgroundArray[i].col = new Vector3(noiseSample.value, noiseSample.value, noiseSample.value); //strokeBackgroundArray[i].normal = -background1[i].normalized; //Vector3 cross = Vector3.Cross(strokeBackgroundArray[i].normal, noiseSample.derivative); strokeBackgroundArray[i].tangent = Vector3.Cross(strokeBackgroundArray[i].normal, noiseSample.derivative); //strokeBackgroundArray[i].prevPos = background1[i]; //size = (1.0f - Mathf.Abs(size)); //0 = 1, strokeBackgroundArray[i].dimensions = new Vector2(1f, 1f); } skyNoiseOffset += skyNoiseScroll * Time.deltaTime; backgroundStrokesBuffer.SetData(strokeBackgroundArray); /*float groundPos = -5f; * for (int i = 0; i < strokeTerrainArray.Length; i++) { * //strokeTerrainArray[i].pos = UnityEngine.Random.insideUnitSphere * groundSpreadExponent; * //strokeTerrainArray[i].pos *= strokeTerrainArray[i].pos.sqrMagnitude; * strokeTerrainArray[i].pos.y = groundPos; // start at groundHeight * NoiseSample noiseSample = NoisePrime.Simplex3D(new Vector3(strokeTerrainArray[i].pos.x, 0f, strokeTerrainArray[i].pos.z), groundNoiseFrequency); * float heightOffset = noiseSample.value * groundNoiseAmplitude; * strokeTerrainArray[i].pos.y = groundPos + heightOffset; * //strokeTerrainArray[i].pos = terrain1[i]; * Color color = terrainColorGradient.Evaluate(noiseSample.value * 0.5f + 0.5f); * strokeTerrainArray[i].col = new Vector3(color.r, color.g, color.b); * //Vector3 preTangent = noiseSample.derivative; * //preTangent.y *= groundNoiseAmplitude; * * //strokeTerrainArray[i].normal = new Vector3(-noiseSample.derivative.x, 1f, -noiseSample.derivative.z); * //Vector3 cross = Vector3.Cross(strokeBackgroundArray[i].normal, noiseSample.derivative); * strokeTerrainArray[i].tangent = Vector3.Cross(strokeTerrainArray[i].normal, noiseSample.derivative); * strokeTerrainArray[i].dimensions = new Vector2(1f, 1f); * * } * terrainStrokesBuffer.SetData(strokeTerrainArray); */ }
// --------------------------------- // // SIMPLEX FUNCTIONS !!! // ---------------------------------- private static NoiseSample Simplex1DPart(Vector3 point, int ix) { float x = point.x - ix; // get relative position of sample point with respect to base integer cell float f = 1f - x * x; float f2 = f * f; float f3 = f * f2; // falloff function f(0)=1, f(1)=0 float g = gradients1D [hash [ix & hashMask] & gradientsMask1D]; float v = g * x; NoiseSample sample = new NoiseSample(); sample.value = v * f3; // multiply h hash value by f3, the contribution of h at this position. sample.derivative.x = g * f3 - 6f * v * x * f2; return(sample); }
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 = PermutationTable[ix & hashMask]; NoiseSample sample = new NoiseSample(); sample.value = h * f3; 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 Value2D(Vector3 point, float frequency, bool derivative) { point *= frequency; int ix0 = Mathf.FloorToInt(point.x); int iy0 = Mathf.FloorToInt(point.y); float tx = point.x - ix0; float ty = point.y - iy0; ix0 &= hashMask; iy0 &= hashMask; int ix1 = ix0 + 1; int iy1 = iy0 + 1; int h0 = GameUtils.Hash[ix0]; int h1 = GameUtils.Hash[ix1]; int h00 = GameUtils.Hash[h0 + iy0]; int h10 = GameUtils.Hash[h1 + iy0]; int h01 = GameUtils.Hash[h0 + iy1]; int h11 = GameUtils.Hash[h1 + iy1]; float txs = GameUtils.Smooth(tx); float tys = GameUtils.Smooth(ty); float a = h00; float b = h10 - h00; float c = h01 - h00; float d = h11 - h01 - h10 + h00; NoiseSample sample = new NoiseSample(); sample.value = a + b * txs + (c + d * txs) * tys; if (derivative) { float dtx = GameUtils.SmoothDerivative(tx); float dty = GameUtils.SmoothDerivative(ty); sample.derivative.x = (b + d * tys) * dtx; sample.derivative.y = (c + d * txs) * dty; sample.derivative.z = 0f; sample.derivative *= frequency; } return(sample * (2f / hashMask) - 1f); }
private void createNoiseAsset() { NoiseSample noiseSample = ScriptableObject.CreateInstance <NoiseSample> (); noiseSample.setScale(scale); noiseSample.setSaturation(saturation); noiseSample.setNoiseScale(weight); noiseSample.setPersistentSample(sample); checkPath(); AssetDatabase.CreateAsset(noiseSample, "Assets/ProcedureTerrain/NoiseSample/" + name + ".asset"); //EditorUtility.SetDirty(sample3D); AssetDatabase.SaveAssets(); }
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)); }
public float interpolateAt(NoiseSample sample, float x, float y, float z) { this.noiseSample = sample; int X0 = fastFloor(x) % (sample.getSample().GetLength(0)-1); int Y0 = fastFloor(y) % (sample.getSample().GetLength(1)-1); int Z0 = fastFloor(z) % (sample.getSample().GetLength(2)-1); x -= fastFloor (x); y -= fastFloor (y); z -= fastFloor (z); float u = fade (x), v = fade (y), w = fade (z); float interpolated = interpolateCube (X0, Y0, Z0, u, v, w); return interpolated; }
private static NoiseSample SimplexGradient1DPart(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[PermutationTable[ix & hashMask] & gradientsMask1D]; float v = g * x; NoiseSample sample = new NoiseSample(); sample.value = v * f3; return(sample); }
// ------------------------- // // SIMPLEX VALUE NOISE FUNCTIONS: // // ======================================================================================================== private static NoiseSample SimplexValue1DPart (Vector3 point, int ix) { float x = point.x - ix; // get relative position of sample point with respect to base integer cell float f = 1f - x * x; float f2 = f * f; float f3 = f * f2; // falloff function f(0)=1, f(1)=0 float h = hash [ix & hashMask]; // get hashed (shuffled) value for this cell int NoiseSample sample = new NoiseSample(); sample.value = h * f3; // multiply h hash value by f3, the contribution of h at this position. 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; }
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; }
public void addSample(NoiseSample sample) { samples.Add (sample); }
// // 2D ======================================================================================================== public 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; // 1 - x^2 - y^2 NoiseSample sample = new NoiseSample(); if (f > 0f) { float f2 = f * f; // f^3 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; }
// // 3D ======================================================================================================== 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; }
// --------------------------------- // // SIMPLEX FUNCTIONS !!! // ---------------------------------- private static NoiseSample Simplex1DPart (Vector3 point, int ix) { float x = point.x - ix; // get relative position of sample point with respect to base integer cell float f = 1f - x * x; float f2 = f * f; float f3 = f * f2; // falloff function f(0)=1, f(1)=0 float g = gradients1D [hash [ix & hashMask] & gradientsMask1D]; float v = g * x; NoiseSample sample = new NoiseSample(); sample.value = v * f3; // multiply h hash value by f3, the contribution of h at this position. sample.derivative.x = g * f3 - 6f * v * x * f2; return sample; }
// // 2D ======================================================================================================== public 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; // 1 - x^2 - y^2 NoiseSample sample = new NoiseSample(); if (f > 0f) { float f2 = f * f; // f^3 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; }
// // 3D ======================================================================================================== 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; }