public static Noise ( float x, float y ) : float | ||
x | float | |
y | float | |
Résultat | float |
public Vector3[] CreateTerrain(float seaLevel) { noise = new Perlin(); Mesh mesh = transform.GetComponent <MeshFilter>().mesh; if (baseVertices == null) // not sure about the scope of this if. potentional bug { baseVertices = mesh.vertices; } Vector3[] vertices = new Vector3[baseVertices.Length]; for (var i = 0; i < vertices.Length; i++) { Vector3 vertex = baseVertices[i]; vertex.x += noise.Noise(vertex.x, vertex.y, vertex.z) * scale; vertex.y += noise.Noise(vertex.x, vertex.y, vertex.z) * scale; vertex.z += noise.Noise(vertex.x, vertex.y, vertex.z) * scale; // flatten out sea if (vertex.magnitude < seaLevel) { vertex = seaLevel * vertex.normalized; } vertices[i] = vertex; } return(vertices); }
private void ShootLightning() { float timex = Time.time * speed * 0.1365143f; float timey = Time.time * speed * 1.21688f; float timez = Time.time * speed * 2.5564f; for (int i = 0; i < particles.Length; i++) { Vector3 position = Vector3.Lerp(transform.position, target.position, oneOverZigs * (float)i); Vector3 offset = new Vector3(noise.Noise(timex + position.x, timex + position.y, timex + position.z), noise.Noise(timey + position.x, timey + position.y, timey + position.z), noise.Noise(timez + position.x, timez + position.y, timez + position.z)); position += (offset * scale * ((float)i * oneOverZigs)); particles[i].position = position; particles[i].color = Color.white; particles[i].energy = 1f; } particleEmitter.particles = particles; if (particleEmitter.particleCount >= 2) { if (startLight) { startLight.transform.position = particles[0].position; } if (endLight) { endLight.transform.position = particles[particles.Length - 1].position; } } }
void Update() { Mesh _mesh = GetComponent <MeshFilter>().mesh; if (Base == null) { Base = new Vector3[_mesh.vertexCount]; Base = _mesh.vertices; } Vector3[] Vertices = _mesh.vertices; float timeX = Time.time * Velocidad; float timeY = Time.time * Velocidad; float timeZ = Time.time * Velocidad; for (int i = 0; i < Vertices.Length; i++) { Vector3 Auxiliar = Base[i]; Auxiliar.x += Perlin_Noise.Noise(timeX + Auxiliar.x, timeX + Auxiliar.y, timeX + Auxiliar.z) * Distorcion; Auxiliar.y += Perlin_Noise.Noise(timeY + Auxiliar.x, timeY + Auxiliar.y, timeY + Auxiliar.z) * Distorcion; Auxiliar.z += Perlin_Noise.Noise(timeZ + Auxiliar.x, timeZ + Auxiliar.y, timeZ + Auxiliar.z) * Distorcion; Vertices[i] = Auxiliar; } _mesh.vertices = Vertices; _mesh.RecalculateNormals(); }
public void CrumpleMesh() { noise = new Perlin(); if (baseVertices == null) { baseVertices = mesh.vertices; } Vector3[] vertices = new Vector3[baseVertices.Length]; timeX += 0.1365143f; timeY += 1.21688f; timeZ += 2.5564f; for (var i = 0; i < vertices.Length; i++) { Vector3 vertex = baseVertices [i]; vertex.x += noise.Noise(timeX + vertex.x, timeX + vertex.y, timeX + vertex.z) * rad; vertex.y += noise.Noise(timeY + vertex.x, timeY + vertex.y, timeY + vertex.z) * rad; vertex.z += noise.Noise(timeZ + vertex.x, timeZ + vertex.y, timeZ + vertex.z) * rad; vertices [i] = vertex; } mesh.vertices = vertices; mesh.RecalculateNormals(); mesh.RecalculateBounds(); mesh.Optimize(); }
public float HybridMultifractal(float x, float y, float offset) { float weight, signal, remainder, result; result = (m_Noise.Noise(x, y) + offset) * m_Exponent[0]; weight = result; x *= m_Lacunarity; y *= m_Lacunarity; int i; for (i = 1; i < m_IntOctaves; i++) { if (weight > 1.0f) { weight = 1.0f; } signal = (m_Noise.Noise(x, y) + offset) * m_Exponent[i]; result += weight * signal; weight *= signal; x *= m_Lacunarity; y *= m_Lacunarity; } remainder = m_Octaves - m_IntOctaves; result += remainder * m_Noise.Noise(x, y) * m_Exponent[i]; return(result); }
public Vector3[] CreateTerrain(float seaLevel) { noise = new Perlin(); Mesh mesh = transform.GetComponent<MeshFilter>().mesh; if (baseVertices == null) // not sure about the scope of this if. potentional bug { baseVertices = mesh.vertices; } Vector3[] vertices = new Vector3[baseVertices.Length]; for (var i=0;i<vertices.Length;i++) { Vector3 vertex = baseVertices[i]; vertex.x += noise.Noise(vertex.x, vertex.y, vertex.z) * scale; vertex.y += noise.Noise(vertex.x, vertex.y, vertex.z) * scale; vertex.z += noise.Noise(vertex.x, vertex.y, vertex.z) * scale; // flatten out sea if (vertex.magnitude < seaLevel) { vertex = seaLevel * vertex.normalized; } vertices[i] = vertex; } return vertices; }
void Update() { var mesh = GetComponent <MeshFilter> ().mesh; if (baseVertices == null) { baseVertices = mesh.vertices; } var vertices = new Vector3[baseVertices.Length]; var timex = Time.time * speed + 0.1365143; var timey = Time.time * speed + 1.21688; var timez = Time.time * speed + 2.5564; for (var i = 0; i < vertices.Length; i++) { var vertex = baseVertices [i]; vertex.x += noise.Noise((float)timex + vertex.x, (float)timex + vertex.y, (float)timex + vertex.z) * scale; vertex.y += noise.Noise((float)timey + vertex.x, (float)timey + vertex.y, (float)timey + vertex.z) * scale; vertex.z += noise.Noise((float)timez + vertex.x, (float)timez + vertex.y, (float)timez + vertex.z) * scale; vertices [i] = vertex; } mesh.vertices = vertices; if (recalculateNormals) { mesh.RecalculateNormals(); } mesh.RecalculateBounds(); }
private void DeformMesh() { float newScale = Random.Range(MinRockSize, MaxRockSize); transform.localScale = new Vector3(newScale, newScale, newScale); var vertices = new Vector3[baseVertices.Length]; var timex = Time.time * Speed; var timey = Time.time * Speed; var timez = Time.time * Speed; for (var i = 0; i < vertices.Length; i++) { var vertex = baseVertices[i]; vertex.x += noise.Noise(timex + vertex.x, timex + vertex.y, timex + vertex.z) * Scale; vertex.y += noise.Noise(timey + vertex.x, timey + vertex.y, timey + vertex.z) * Scale; vertex.z += noise.Noise(timez + vertex.x, timez + vertex.y, timez + vertex.z) * Scale; vertices[i] = vertex; } mesh.vertices = vertices; if (RecalculateNormals) { mesh.RecalculateNormals(); } mesh.RecalculateBounds(); collider.sharedMesh = mesh; }
void Update() { int length = particle_system.GetParticles(particles); if (noise == null) { noise = new Perlin(); } float timex = Time.time * speed * 0.1365143f; float timey = Time.time * speed * 1.21688f; float timez = Time.time * speed * 2.5564f; for (int i = 0; i < length; i++) { Vector3 position = Vector3.Lerp(transform.position, target.position, oneOverZigs * (float)i); Vector3 offset = new Vector3(noise.Noise(timex + position.x, timex + position.y, timex + position.z), noise.Noise(timey + position.x, timey + position.y, timey + position.z), noise.Noise(timez + position.x, timez + position.y, timez + position.z)); position += (offset * scale * ((float)i * oneOverZigs)); particles[i].position = position; // particles[i].color = Color.white; // particles[i].energy = 1f; } particle_system.SetParticles(particles, length); }
void Update() { if (Input.GetKeyUp(KeyCode.N)) { IsStart = !IsStart; GetComponent <ParticleEmitter>().enabled = IsStart; this.GetComponent <ParticleRenderer>().enabled = IsStart; if (startLight) { startLight.enabled = IsStart; } if (endLight) { endLight.enabled = IsStart; } } if (!IsStart) { return; } if (noise == null) { noise = new Perlin(); } float timex = Time.time * speed * 0.1365143f; float timey = Time.time * speed * 1.21688f; float timez = Time.time * speed * 2.5564f; for (int i = 0; i < particles.Length; i++) { Vector3 position = Vector3.Lerp(transform.position, target.position + targetOffset, oneOverZigs * (float)i); Vector3 offset = new Vector3(noise.Noise(timex + position.x, timex + position.y, timex + position.z), noise.Noise(timey + position.x, timey + position.y, timey + position.z), noise.Noise(timez + position.x, timez + position.y, timez + position.z)); position += (offset * scale * ((float)i * oneOverZigs)); particles[i].position = position; particles[i].color = Color.white; particles[i].energy = 1f; } GetComponent <ParticleEmitter>().particles = particles; if (GetComponent <ParticleEmitter>().particleCount >= 2) { if (startLight) { startLight.transform.position = particles[0].position; } if (endLight) { endLight.transform.position = particles[particles.Length - 1].position; } } }
// Deform mesh. private void DeformMesh() { var vertices = new Vector3[baseVertices.Count]; var timex = Time.time * Speed; var timey = Time.time * Speed; var timez = Time.time * Speed; for (var i = 0; i < vertices.Length; i++) { var vertex = baseVertices[i]; vertex.x += noise.Noise(timex + vertex.x, timex + vertex.y, timex + vertex.z) * Scale; vertex.y += noise.Noise(timey + vertex.x, timey + vertex.y, timey + vertex.z) * Scale; vertex.z += noise.Noise(timez + vertex.x, timez + vertex.y, timez + vertex.z) * Scale; vertices[i] = vertex; } mesh.vertices = vertices; if (RecalculateNormals) { mesh.RecalculateNormals(); } mesh.RecalculateBounds(); collider.sharedMesh = mesh; }
void Update() { Mesh mesh = GetComponent <MeshFilter>().mesh; if (baseVertices == null) { baseVertices = mesh.vertices; } Vector3[] vertices = new Vector3[baseVertices.Length]; float timeX = Time.time * speed + 0.1365143f; float timeY = Time.time * speed + 1.21688f; float timeZ = Time.time * speed + 2.5564f; for (int i = 0; i < vertices.Length; i++) { Vector3 vertex = baseVertices[i]; vertex.x += noise.Noise(timeX + vertex.x, timeX + vertex.y, timeX + vertex.z) * scale; vertex.y += noise.Noise(timeY + vertex.x, timeY + vertex.y, timeY + vertex.z) * scale; vertex.z += noise.Noise(timeZ + vertex.x, timeZ + vertex.y, timeZ + vertex.z) * scale; vertices[i] = vertex; } mesh.vertices = vertices; if (recalculateNormals) { mesh.RecalculateNormals(); } mesh.RecalculateBounds(); }
public void step() { x = (int)((perlin.Noise(tx, 0.1, 0.1) + 0.5f) * width); y = (int)((perlin.Noise(ty, 0.1, 0.1) + 0.5f) * height); tx += 0.005f; ty += 0.005f; }
void Update() { if (active) { audio.mute = false; if (noise == null) { noise = new Perlin(); } float timex = Time.time * speed * 0.1365143f; float timey = Time.time * speed * 1.21688f; float timez = Time.time * speed * 2.5564f; for (int i = 0; i < particles.Length; i++) { Vector3 position = Vector3.Lerp(transform.position, target, oneOverZigs * (float)i); Vector3 offset = new Vector3(noise.Noise(timex + position.x, timex + position.y, timex + position.z), noise.Noise(timey + position.x, timey + position.y, timey + position.z), noise.Noise(timez + position.x, timez + position.y, timez + position.z)); position += (offset * scale * ((float)i * oneOverZigs)); particles [i].position = position; particles [i].color = Color.white; particles [i].energy = 1f; } particleEmitter.particles = particles; if (particleEmitter.particleCount >= 2) { if (startLight) { startLight.transform.position = particles [0].position; startLight.range = 0.4f; } if (endLight) { endLight.transform.position = particles [particles.Length - 1].position; endLight.range = 10; } } } else { particleEmitter.particles = null; audio.mute = true; if (endLight) { endLight.range = 0; } if (startLight) { startLight.range = 0; } } }
void Update() { float perlinSpeed = 0.66f; float perlinSize = 0.15f; Vector3 perlinOffset = new Vector3(perlin.Noise(Time.time * perlinSpeed), perlin.Noise(Time.time * perlinSpeed + 124.27f), perlin.Noise(Time.time * perlinSpeed + 254.57f)) * perlinSize; transform.position = Vector3.Lerp(transform.position, targetSource.transform.position + targetSource.transform.forward * distanceFromTarget + transform.TransformDirection(perlinOffset), Time.deltaTime * lerpSpeed); transform.rotation = targetSource.transform.rotation; }
// private methods ---------------------------- // unique ----------------------------- void CalculatePerlinNoise() { perlinPoint = new Vector2[nodes.Length]; gradients = new float[nodes.Length][, ]; for (int a = 0; a < nodes.Length; a++) { perlinPoint[a] = new Vector2((float)Pow(-1, rnd.Next(1, 2)) * 500f * (float)rnd.NextDouble(), (float)Pow(-1, rnd.Next(1, 2)) * 500f * (float)rnd.NextDouble()); gradients [a] = new float[size, size]; float maxValue = float.MinValue; float minValue = float.MaxValue; for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { float x = (float)i * 0.39f * 0.39f; float y = (float)j * 0.39f * 0.39f; float newValue = Abs(perlin.Noise(x + perlinPoint[a].x, y + perlinPoint[a].y)); float m = 1f; for (int k = 0; k < 5; k++) { x /= 2f; y /= 2f; m *= 2.1f; newValue += m * Abs(perlin.Noise(x + perlinPoint[a].x, y + perlinPoint[a].y)); } gradients[a][j, i] = newValue; if (newValue > maxValue) { maxValue = newValue; } if (newValue < minValue) { minValue = newValue; } } } for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { float result = (gradients[a][j, i] - minValue) / (maxValue - minValue); result = result - result % 0.05f; if (result >= 1 - 7 * 0.05f) { result = 0.99f; } if (result <= 7 * 0.05f) { result = 0f; } gradients[a][j, i] = result; } } } }
void Update() { if (textMeshStr != currentTextMeshStr && textMeshFound) { Debug.Log("Setting new text to: " + textMeshStr); textMesh.text = textMeshStr; currentTextMeshStr = textMeshStr; } if (noise == null) { noise = new Perlin(); } float timex = Time.time * speed * 0.1365143f; float timey = Time.time * speed * 1.21688f; float timez = Time.time * speed * 2.5564f; for (int i = 0; i < particles.Length; i++) { Vector3 position = Vector3.Lerp(transform.position, target.position, oneOverZigs * (float)i); Vector3 offset = new Vector3(noise.Noise(timex + position.x, timex + position.y, timex + position.z), noise.Noise(timey + position.x, timey + position.y, timey + position.z), noise.Noise(timez + position.x, timez + position.y, timez + position.z)); position += (offset * scale * ((float)i * oneOverZigs)); particles[i].position = position; particles[i].color = Color.white; particles[i].energy = 1f; } particleEmitter.particles = particles; if (particleEmitter.particleCount >= 2) { if (startLight) { startLight.transform.position = particles[0].position; } if (endLight) { endLight.transform.position = particles[particles.Length - 1].position; } } // update textMesh position if (textMesh != null) { Vector3 pos = new Vector3(this.transform.position.x, this.transform.position.y + 1, this.transform.position.z); textMesh.transform.position = pos; } }
/** * Retrieves the wind vector at the given location. */ public Vector3 WindVelocityAt(Vector3 position) { float timeTurbulence = Time.time * turbulenceFrequency; float timeX = timeTurbulence * 0.1365143f; float timeY = timeTurbulence * 1.21688f; float timeZ = timeTurbulence * 2.5564f; Vector3 turbulence = new Vector3(perlin.Noise(timeX + position.x, timeX + position.y, timeX + position.z), perlin.Noise(timeY + position.x, timeY + position.y, timeY + position.z), perlin.Noise(timeZ + position.x, timeZ + position.y, timeZ + position.z)) * turbulenceAmplitude; return(windVelocity + turbulence); }
void Update() { if (!gameManager.isPaused && !gameManager.isGameOver) { if (target != null) { GetComponent <ParticleRenderer>().enabled = true; if (noise == null) { noise = new Perlin(); } float timex = Time.time * speed * 0.1365143f; float timey = Time.time * speed * 1.21688f; float timez = Time.time * speed * 2.5564f; for (int i = 0; i < particles.Length; i++) { Vector3 position = Vector3.Lerp(transform.position, target.position, oneOverZigs * (float)i); Vector3 offset = new Vector3(noise.Noise(timex + position.x, timex + position.y, timex + position.z), noise.Noise(timey + position.x, timey + position.y, timey + position.z), noise.Noise(timez + position.x, timez + position.y, timez + position.z)); position += (offset * 0.3f * scale * ((float)i * oneOverZigs)); particles[i].position = position; particles[i].color = Color.white; particles[i].energy = 1f; } GetComponent <ParticleEmitter>().particles = particles; if (GetComponent <ParticleEmitter>().particleCount >= 2) { if (startLight) { startLight.transform.position = particles[0].position; } if (endLight) { endLight.transform.position = particles[particles.Length - 1].position; } } } else { GetComponent <ParticleRenderer>().enabled = false; } } }
void Update() { if (noise == null) { noise = new Perlin(); } float timex = Time.time * speed * 0.1365143f; float timey = Time.time * speed * 1.21688f; float timez = Time.time * speed * 2.5564f; particles = new ParticleSystem.Particle[GetComponent <ParticleSystem>().particleCount]; int total = GetComponent <ParticleSystem>().GetParticles(particles); for (int i = 0; i < particles.Length; i++) { if (null == target) { return; } Vector3 position = Vector3.Lerp(transform.position, target.position, oneOverZigs * (float)i); Vector3 offset = new Vector3(noise.Noise(timex + position.x, timex + position.y, timex + position.z), noise.Noise(timey + position.x, timey + position.y, timey + position.z), noise.Noise(timez + position.x, timez + position.y, timez + position.z)); position += (offset * scale * ((float)i * oneOverZigs)); particles[i].position = position; particles[i].color = Color.white; // particles[i].energy = 1f; } GetComponent <ParticleSystem>().SetParticles(particles, particles.Length); // Debug.Log("parsyscount:"+GetComponent<ParticleSystem>().particleCount); // Debug.Log("setting particles. nth:"+particles[Random.Range(0,99)].position); if (GetComponent <ParticleSystem>().particleCount >= 2) { if (startLight) { startLight.transform.position = particles[0].position; } if (endLight) { endLight.transform.position = particles[particles.Length - 1].position; } } }
void Update() { if (!target) { return; } if (!IsActive) { return; } if (_noise == null) { _noise = new Perlin(); } float timex = Time.time * speed * 0.1365143f; float timey = Time.time * speed * 1.21688f; float timez = Time.time * speed * 2.5564f; for (int i = 0; i < _particles.Length; i++) { Vector3 position = Vector3.Lerp(transform.position + originOffset, target.position + targetOffset, _oneOverZigs * (float)i); float offsetX = restrainZigX ? 0 : _noise.Noise(timex + position.x, timex + position.y, timex + position.z); float offsetY = restrainZigY ? 0 : _noise.Noise(timey + position.x, timey + position.y, timey + position.z); float offsetZ = restrainZigZ ? 0 : _noise.Noise(timez + position.x, timez + position.y, timez + position.z); Vector3 offset = new Vector3(offsetX, offsetY, offsetZ); position += (offset * scale * ((float)i * _oneOverZigs)); _particles[i].position = position; _particles[i].color = color; _particles[i].energy = 1f; } GetComponent <ParticleEmitter>().particles = _particles; if (GetComponent <ParticleEmitter>().particleCount >= 2) { if (startLight) { startLight.transform.position = _particles[0].position; } if (endLight) { endLight.transform.position = _particles[_particles.Length - 1].position; } } }
public static BitmapVideoFrameWrapper CreateVideoFrame(int index, PixelFormat fmt, int w, int h, float scaleNoise, float offset) { var bitmap = new Bitmap(w, h, fmt); offset = offset * index; for (int y = 0; y < h; y++) { for (int x = 0; x < w; x++) { var xf = x / (float)w; var yf = y / (float)h; var nx = x * scaleNoise + offset; var ny = y * scaleNoise + offset; var value = (int)((Perlin.Noise(nx, ny) + 1.0f) / 2.0f * 255); var color = Color.FromArgb((int)(value * xf), (int)(value * yf), value); bitmap.SetPixel(x, y, color); } } return(new BitmapVideoFrameWrapper(bitmap)); }
// Update is called once per frame void Update() { int i = 0; for (int x = 0; x < noSpheresX; x++) { for (int y = 0; y < noSpheresY; y++) { for (int z = 0; z < noSpheresZ; z++) { Vector3 pos = new Vector3(x, y, z); pos.x += ampPerlin * Perlin.Noise(x * freqPerlin + speedPerlin * Time.time, y * freqPerlin, z * freqPerlin); pos.y += ampPerlin * Perlin.Noise(x * freqPerlin + speedPerlin * Time.time, y * freqPerlin, z * freqPerlin + 13.2f); pos.z += ampPerlin * Perlin.Noise(x * freqPerlin + speedPerlin * Time.time, y * freqPerlin, z * freqPerlin + 49.9f); float scaleP = 1f + sizePerlin * Perlin.Noise(x * freqPerlin + speedPerlin * Time.time, y * freqPerlin, z * freqPerlin + 121.3f); pos.x += (0.9f * scaleP + 0.1f) * ampVibrate * (Mathf.Sin(speedVibrate * Time.time + phaseVibrate * i)); pos.y += (0.9f * scaleP + 0.1f) * ampVibrate * (Mathf.Cos(speedVibrate * Time.time + phaseVibrate * i)); pos.z += (0.9f * scaleP + 0.1f) * ampVibrate * (Mathf.Cos(speedVibrate * Time.time + 0.5f * Mathf.PI + phaseVibrate * i)); spheres [i].transform.localPosition = pos; Vector3 scale = new Vector3(size, size, size); scale *= scaleP; spheres [i].transform.localScale = scale; i++; } } } }
public float Calculate(Vector2 texturePosition, float scaleInput, int x, int y, int z) { perlin = new Perlin(seed); fractal = new FractalNoise(h, lacunarity, octaves, perlin); float value = 0; switch (noiseType) { case NoiseType.Brownian: value = fractal.BrownianMotion(x * scale * scaleInput + texturePosition.x, y * scale * scaleInput, z * scale * scaleInput + texturePosition.y); break; case NoiseType.HybridMultifractal: value = fractal.HybridMultifractal(x * scale * scaleInput + texturePosition.x, y * scale * scaleInput, z * scale * scaleInput + texturePosition.y, offset); break; case NoiseType.RidgedMultifractal: value = fractal.RidgedMultifractal(x * scale * scaleInput + texturePosition.x, y * scale * scaleInput, z * scale * scaleInput + texturePosition.y, offset, gain); break; case NoiseType.Perlin: value = perlin.Noise(x * scale * scaleInput + texturePosition.x, y * scale * scaleInput, z * scale * scaleInput + texturePosition.y); break; } return(value); }
void Generate() { Vector3[] vertices = _meshfilter.mesh.vertices; int zi = 0; for (int i = 0; i < vertices.Length; i++) { vertices[i] += _meshfilter.mesh.normals[i] * ((Perlin.Noise(offset + vertices[i] * noisesScale) / 255f) * roughness); } _meshfilter.mesh.vertices = vertices; _meshfilter.mesh.RecalculateBounds(); for (int i = 0; i < vertices.Length; i++) { if (vertices[i].z <= 0.01 && vertices[i].z >= -0.01) { z_vertices.Add(vertices[i]); zi++; float height = CalculateHeight(vertices[i]); if (height >= 0.5f && height < 2f) { seaLevel_index.Add(zi); } } } SpawnBuilding(); SpawnPerson(); }
static void makePerlinElevation(PlanetData planet, IRandomGenerator gen, PlanetGeneratorData.ElevationData.PerlinFactors[] perlinFactors) { const float maxPerlinOffset = 10000; float minValue = float.MaxValue; float maxValue = float.MinValue; Vector3[] perlinOffset = new Vector3[perlinFactors.Length]; for (int i = 0; i < perlinOffset.Length; i++) { perlinOffset[i] = new UniformVector3BoxDistribution(-maxPerlinOffset, maxPerlinOffset, -maxPerlinOffset, maxPerlinOffset, -maxPerlinOffset, maxPerlinOffset).Next(gen); } for (int i = 0; i < planet.points.Length; i++) { float scale = 0; for (int j = 0; j < perlinFactors.Length; j++) { scale += Perlin.Noise(perlinOffset[j] + planet.points[i].point * perlinFactors[j].frequency) * perlinFactors[j].amplitude; } planet.points[i].height = scale; minValue = Mathf.Min(minValue, scale); maxValue = Mathf.Max(maxValue, scale); } for (int i = 0; i < planet.points.Length; i++) { planet.points[i].height = (planet.points[i].height - minValue) / (maxValue - minValue) * 2 - 1; // range [-1,1] } }
public void Perturb(float f, float d) { int v, u; float[,] temp = new float[Size, Size]; for (int z = 0; z < Size; z++) { for (int x = 0; x < Size; x++) { v = z + (int)(Perlin.Noise(f * z / (float)Size, f * x / (float)Size, 0) * d); u = x + (int)(Perlin.Noise(f * z / (float)Size, f * x / (float)Size, 1) * d); if (v < 0) { v = 0; } if (v >= Size) { v = Size - 1; } if (u < 0) { u = 0; } if (u >= Size) { u = Size - 1; } temp[x, z] = Heights[u, v]; } } Heights = temp; }
/* * BiomeHandler's main function * Used to assign a biome to a new chunk. * Play arround with the seed value in each of the 4 biome features to change the behaviour * of the biome distribution. */ public byte Assign(ChunkPos pos) { float currentAltitude = Perlin.Noise(pos.x * BiomeHandlerData.featureModificationConstant * BiomeHandlerData.ax + ((dispersionSeed * BiomeHandlerData.ss) % 1000), pos.z * BiomeHandlerData.featureModificationConstant * BiomeHandlerData.az + ((dispersionSeed * BiomeHandlerData.sx) % 1000)); float currentHumidity = Perlin.Noise(pos.x * BiomeHandlerData.featureModificationConstant * BiomeHandlerData.bx + ((dispersionSeed * BiomeHandlerData.ss) % 1000), pos.z * BiomeHandlerData.featureModificationConstant * BiomeHandlerData.bz + ((dispersionSeed * BiomeHandlerData.sy) % 1000)); float currentTemperature = Perlin.Noise(pos.x * BiomeHandlerData.featureModificationConstant * BiomeHandlerData.cx + ((dispersionSeed * BiomeHandlerData.ss) % 1000), pos.z * BiomeHandlerData.featureModificationConstant * BiomeHandlerData.cz + ((dispersionSeed * BiomeHandlerData.sz) % 1000)); float currentLightning = Perlin.Noise(pos.x * BiomeHandlerData.featureModificationConstant * BiomeHandlerData.dx + ((dispersionSeed * BiomeHandlerData.ss) % 1000), pos.z * BiomeHandlerData.featureModificationConstant * BiomeHandlerData.dz + ((dispersionSeed * BiomeHandlerData.sw) % 1000)); float lowestDistance = 99; byte lowestBiome = 255; float distance; float4 currentSettings = new float4(currentAltitude, currentHumidity, currentTemperature, currentLightning); for (byte s = 0; s < amountOfBiomes; s++) { distance = BiomeHandler.Distance(currentSettings, BiomeHandlerData.codeToStats[s]); if (distance <= lowestDistance) { lowestDistance = distance; lowestBiome = s; } } return(lowestBiome); }
float GetScale(Vector3 position) { var noffs = Vector3.up * _noiseSpeed * Time.time; var s = Perlin.Noise(position * _noiseFrequency + noffs); return(Mathf.Lerp(_minScale, _maxScale, (s + 1) / 2)); }
public TerrainPerlin(GameObject voxel, float voxel_size, float x_offset, float y_offset, float scene_width, float ratio) { voxels = new Dictionary <string, GameObject>(); float rx = Random.Range(-1000.0f, 1000.0f); float ry = Random.Range(-1000.0f, 1000.0f); for (float y = 5; y > -5.0f; y -= voxel_size) { for (float x = 0; x < scene_width; x += voxel_size) { if (Perlin.Noise((x + rx) / 2.5f, (y + ry) / 1.8f) > 0.06f) { GameObject v = GameObject.Instantiate(voxel); v.transform.position = new Vector3(x + x_offset, y + y_offset, 0.0f); string index = Mathf.Round(x / voxel_size) + "," + Mathf.Round(y / voxel_size); voxels[index] = v; } } } float yy = -4.9f; for (float x = 0; x < scene_width; x += voxel_size) { GameObject v = GameObject.Instantiate(voxel); v.transform.position = new Vector3(x + x_offset, yy + y_offset, 0.0f); string index = Mathf.Round(x / voxel_size) + "," + Mathf.Round(yy / voxel_size); voxels[index] = v; } }
private void _CalcVerts() { List <Vector3> _tempVerts = new List <Vector3>(); List <Vector2> _tempUVs = new List <Vector2>(); for (int i = 0; i <= 8; i++) { for (int j = 0; j <= 8; j++) { float X = (float)(originPoint.x + j); float Z = (float)(originPoint.z + i); Vector3 pos = new Vector3(X, 30 * Perlin.Noise(X / 4, Z / 4) * Perlin.Noise(X / 16.23f, Z / 50.23f), Z); //Vector3 pos = new Vector3(X, Mathf.Abs(Perlin.Noise(X/64, Z/64) * 30 * Perlin.Noise(X/8, Z/8)) + Perlin.Noise(X / 16, Z / 16), Z); //Debug.Log(pos); _tempVerts.Add(pos); _tempUVs.Add(new Vector2((float)i / 8, (float)j / 8)); } } _vertices = new Vector3[_tempVerts.Count]; for (int i = 0; i < _vertices.Length; i++) { _vertices[i] = _tempVerts[i]; } _uvs = new Vector2[_tempUVs.Count]; for (int i = 0; i < _uvs.Length; i++) { _uvs[i] = _tempUVs[i]; } }
IEnumerator Generation() { int num = 0; speed = Random.Range(0.7f, 1.3f); scale = Random.Range(0.4f, 0.7f); noise = new Perlin(); while(num < Random.Range(20,50)) { var vertices = new Vector3[baseVertices.Length]; float timex = Time.time * speed + 0.1365143f; float timey = Time.time * speed + 1.21688f; float timez = Time.time * speed + 2.5564f; for(int j = 0; j < vertices.Length; j++) { var vertex = baseVertices [j]; vertex.x += noise.Noise (timex + vertex.x, timex + vertex.y, timex + vertex.z) * scale; vertex.y += noise.Noise (timey + vertex.x, timey + vertex.y, timey + vertex.z) * scale; vertex.z += noise.Noise (timez + vertex.x, timez + vertex.y, timez + vertex.z) * scale; vertices [j] = vertex; } sourceMesh.vertices = vertices; sourceMesh.RecalculateNormals(); sourceMesh.RecalculateBounds(); num++; yield return new WaitForSeconds (0.01f); } //sourceMesh.Optimize(); //workingMesh.vertices = SmoothFilter.hcFilter(sourceMesh.vertices, workingMesh.vertices, workingMesh.triangles, 0.0f, 0.5f); Vector2 offset = new Vector2(256, 128); int rand = Random.Range(0,6); /*switch(rand) { case 0: offset = new Vector2(0, 0); break; case 1: offset = new Vector2(256, 0); break; case 2: offset = new Vector2(512, 0); break; case 3: offset = new Vector2(0, 128); break; case 4: offset = new Vector2(256, 128); break; case 5: offset = new Vector2(512, 128); break; case 6: offset = new Vector2(0, 256); break; case 7: offset = new Vector2(256, 256); break; }*/ meshR.material = Resources.Load ("Material/asteroid" + rand) as Material ; //meshR.material.SetTexture(rand,SystemGenerator.sprites[rand]); }
public float[] CreateTerrain(float scale) { Perlin noise = new Perlin(); float[] alts = new float[vertices.Length]; for (var i=0;i<nmbrHexs;i++) { Vector3 vertex = vertices[i]; vertex.x += noise.Noise(vertex.x, vertex.y, vertex.z) * scale; vertex.y += noise.Noise(vertex.x, vertex.y, vertex.z) * scale; vertex.z += noise.Noise(vertex.x, vertex.y, vertex.z) * scale; // NOTE: This section needs a bit of work! // freeze polar seas! if (Mathf.Abs(vertex.y)+0.5f>articCircle) { //alts[i] = Mathf.Max(seaLevel+gap, 1+vertex.magnitude); } } return alts; }