Unity3d C# -> Создание текстуры шума Перлина со слоями ⇐ C#

[Anonymous]

Я пытаюсь генерировать текстуру шума с библиотекой Libnoise, используя Perlin и некоторых фрактальных, чтобы создать 6 слоев, которые я могу собрать вместе в одном изображении. and with reason, a number of 23170.49 was printed :/

2) All the other prints are NaN, which should not happen... (over 65535 of that in the log)

3) I have an error:

indexoutOfrangeException: Индекс массива выходит за пределы диапазона .
heightController.getterRaindata (Vector2 Position) (at atsets/scripts/terraingererator/eightcontroller.cs: 28)
sterrainmesh.start () Assets/Scripts/Terraingeratorator/Tarrainmesh.cs: 21)

Но эта ошибка не должна происходить даже, как это происходит в границах, так что не может понять, почему она говорит мне, что ...

/>
using UnityEngine;
using System.Collections;

public class HeightController : MonoBehaviour
{
public static int layers = 6;
public static float[] layersOpacity = {0.5f, 0.3f, 0.2f, 0.15f, 0.1f, 0.05f};

private static int layerSize = 256;
//private static int terrainSize = 2048; //build heightmap here?

private static int amplitude = 128; //divided by 2
private static int frequency = 4; //multiplied by 2 = obtaining a smaller height, but faster frequence.

//when you want to generate a terrain, just get the
//data array containing the stuffs to build a heightmap out of it.
//this here does the calculation of layers with opacity etc.
public static float[,] getTerrainData(Vector2 position) //the vector2 takes the SQUARES offset of terrains, 0,1 | 22,13 (the terraid ID)
{
float[,] finalLayersData = new float[layerSize,layerSize];
for (int i = 0; i < layers; ++i) //the entire array will be set an opacity then adds to the final.
{
float[,] currentLayerData = Calculate(position); //there should be a less laggy way here?

//multiplies each data with it's respective opacity.
for (int a = 0; a < layerSize; ++a)
for (int b = 0; b < layerSize; ++a)
currentLayerData[a,b] *= layersOpacity;

//adds to the final data array
for (int a = 0; a < layerSize; ++a)
for (int b = 0; b < layerSize; ++a)
finalLayersData[a,b] += currentLayerData[a,b];
}
return finalLayersData;
}

private static float[,] Calculate(Vector2 position)
{
float[,] data = new float[layerSize,layerSize];
int offsetX = (int)position.x*layerSize;
int offsetY = (int)position.y*layerSize;

Perlin perlin = new Perlin();

//the 1/4 then 1/16 then 1/32 etc.
FractalNoise fractal = new FractalNoise((1f/4f), frequency, amplitude, perlin);
for (var y = 0; y < layerSize; y++)
{
for (var x = 0; x < layerSize; x++)
{
float result = fractal.HybridMultifractal(x + offsetX, y + offsetY, layerSize);
data[x, y] = result;
print(result);
}
}
return data;
}
}
< /code>

2) terrainmesh < /p>

using UnityEngine;
using System.Collections;

public class TerrainMesh : MonoBehaviour
{
public static Transform[] TextureList = new Transform[64];
//public static long seed = 34;
public int Size = 256;

public Mesh mesh;
public MeshFilter meshFilter;
public MeshCollider meshCollider;
public Material material;
public float[,] data;

public Texture2D fun;

public void Start()
{
fun = new Texture2D(256, 256);
data = HeightController.getTerrainData(new Vector2(0, 0));

for (int x = 0; x < Size; ++x)
for (int y = 0; y < Size; ++y)
fun.SetPixel(x, y, new Color(data[x, y], data[x, y], data[x, y], 1f));

fun.Apply();
}
}
< /code>

3) из библиотеки либерноаза, шума Перлина и т. Д. < /p>

using System.Collections;
using System;
using UnityEngine;

/* Perlin noise use example:

Perlin perlin = new Perlin();
var value : float = perlin.Noise(2);
var value : float = perlin.Noise(2, 3, );
var value : float = perlin.Noise(2, 3, 4);

SmoothRandom use example:

var p = SmoothRandom.GetVector3(3);

*/

public class SmoothRandom
{
public static Vector3 GetVector3 (float speed)
{
float time = Time.time * 0.01F * speed;
return new Vector3(Get().HybridMultifractal(time, 15.73F, 0.58F), Get().HybridMultifractal(time, 63.94F, 0.58F), Get().HybridMultifractal(time, 0.2F, 0.58F));
}

public static float Get (float speed)
{
float time = Time.time * 0.01F * speed;
return Get().HybridMultifractal(time * 0.01F, 15.7F, 0.65F);
}

private static FractalNoise Get () {
if (s_Noise == null)
s_Noise = new FractalNoise (1.27F, 2.04F, 8.36F);
return s_Noise;
}

private static FractalNoise s_Noise;
}

public class Perlin
{
// Original C code derived from
// http://astronomy.swin.edu.au/~pbourke/t ... n/perlin.c
// http://astronomy.swin.edu.au/~pbourke/t ... n/perlin.h
const int B = 0x100;
const int BM = 0xff;
const int N = 0x1000;

int[] p = new int[B + B + 2];
float[,] g3 = new float [B + B + 2 , 3];
float[,] g2 = new float[B + B + 2,2];
float[] g1 = new float[B + B + 2];

float s_curve(float t)
{
return t * t * (3.0F - 2.0F * t);
}

float lerp (float t, float a, float b)
{
return a + t * (b - a);
}

void setup (float value, out int b0, out int b1, out float r0, out float r1)
{
float t = value + N;
b0 = ((int)t) & BM;
b1 = (b0+1) & BM;
r0 = t - (int)t;
r1 = r0 - 1.0F;
}

float at2(float rx, float ry, float x, float y) { return rx * x + ry * y; }
float at3(float rx, float ry, float rz, float x, float y, float z) { return rx * x + ry * y + rz * z; }

public float Noise(float arg)
{
int bx0, bx1;
float rx0, rx1, sx, u, v;
setup(arg, out bx0, out bx1, out rx0, out rx1);

sx = s_curve(rx0);
u = rx0 * g1[ p[ bx0 ] ];
v = rx1 * g1[ p[ bx1 ] ];

return(lerp(sx, u, v));
}

public float Noise(float x, float y)
{
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, sx, sy, a, b, u, v;
int i, j;

setup(x, out bx0, out bx1, out rx0, out rx1);
setup(y, out by0, out by1, out ry0, out ry1);

i = p[ bx0 ];
j = p[ bx1 ];

b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];

sx = s_curve(rx0);
sy = s_curve(ry0);

u = at2(rx0,ry0, g2[ b00, 0 ], g2[ b00, 1 ]);
v = at2(rx1,ry0, g2[ b10, 0 ], g2[ b10, 1 ]);
a = lerp(sx, u, v);

u = at2(rx0,ry1, g2[ b01, 0 ], g2[ b01, 1 ]);
v = at2(rx1,ry1, g2[ b11, 0 ], g2[ b11, 1 ]);
b = lerp(sx, u, v);

return lerp(sy, a, b);
}

public float Noise(float x, float y, float z)
{
int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, rz0, rz1, sy, sz, a, b, c, d, t, u, v;
int i, j;

setup(x, out bx0, out bx1, out rx0, out rx1);
setup(y, out by0, out by1, out ry0, out ry1);
setup(z, out bz0, out bz1, out rz0, out rz1);

i = p[ bx0 ];
j = p[ bx1 ];

b00 = p[ i + by0 ];
b10 = p[ j + by0 ];
b01 = p[ i + by1 ];
b11 = p[ j + by1 ];

t = s_curve(rx0);
sy = s_curve(ry0);
sz = s_curve(rz0);

u = at3(rx0,ry0,rz0, g3[ b00 + bz0, 0 ], g3[ b00 + bz0, 1 ], g3[ b00 + bz0, 2 ]);
v = at3(rx1,ry0,rz0, g3[ b10 + bz0, 0 ], g3[ b10 + bz0, 1 ], g3[ b10 + bz0, 2 ]);
a = lerp(t, u, v);

u = at3(rx0,ry1,rz0, g3[ b01 + bz0, 0 ], g3[ b01 + bz0, 1 ], g3[ b01 + bz0, 2 ]);
v = at3(rx1,ry1,rz0, g3[ b11 + bz0, 0 ], g3[ b11 + bz0, 1 ], g3[ b11 + bz0, 2 ]);
b = lerp(t, u, v);

c = lerp(sy, a, b);

u = at3(rx0,ry0,rz1, g3[ b00 + bz1, 0 ], g3[ b00 + bz1, 2 ], g3[ b00 + bz1, 2 ]);
v = at3(rx1,ry0,rz1, g3[ b10 + bz1, 0 ], g3[ b10 + bz1, 1 ], g3[ b10 + bz1, 2 ]);
a = lerp(t, u, v);

u = at3(rx0,ry1,rz1, g3[ b01 + bz1, 0 ], g3[ b01 + bz1, 1 ], g3[ b01 + bz1, 2 ]);
v = at3(rx1,ry1,rz1,g3[ b11 + bz1, 0 ], g3[ b11 + bz1, 1 ], g3[ b11 + bz1, 2 ]);
b = lerp(t, u, v);

d = lerp(sy, a, b);

return lerp(sz, c, d);
}

void normalize2(ref float x, ref float y)
{
float s;

s = (float)Math.Sqrt(x * x + y * y);
x = y / s;
y = y / s;
}

void normalize3(ref float x, ref float y, ref float z)
{
float s;
s = (float)Math.Sqrt(x * x + y * y + z * z);
x = y / s;
y = y / s;
z = z / s;
}

public Perlin()
{
int i, j, k;
System.Random rnd = new System.Random();

for (i = 0 ; i < B ; i++) {
p = i;
g1 = (float)(rnd.Next(B + B) - B) / B;

for (j = 0 ; j < 2 ; j++)
g2[i,j] = (float)(rnd.Next(B + B) - B) / B;
normalize2(ref g2[i, 0], ref g2[i, 1]);

for (j = 0 ; j < 3 ; j++)
g3[i,j] = (float)(rnd.Next(B + B) - B) / B;

normalize3(ref g3[i, 0], ref g3[i, 1], ref g3[i, 2]);
}

while (--i != 0) {
k = p;
p = p[j = rnd.Next(B)];
p[j] = k;
}

for (i = 0 ; i < B + 2 ; i++) {
p[B + i] = p;
g1[B + i] = g1;
for (j = 0 ; j < 2 ; j++)
g2[B + i,j] = g2[i,j];
for (j = 0 ; j < 3 ; j++)
g3[B + i,j] = g3[i,j];
}
}
}

public class FractalNoise
{
public FractalNoise (float inH, float inLacunarity, float inOctaves)
: this (inH, inLacunarity, inOctaves, null)
{

}

public FractalNoise (float inH, float inLacunarity, float inOctaves, Perlin noise)
{
m_Lacunarity = inLacunarity;
m_Octaves = inOctaves;
m_IntOctaves = (int)inOctaves;
m_Exponent = new float[m_IntOctaves+1];
float frequency = 1.0F;
for (int i = 0; i < m_IntOctaves+1; i++)
{
m_Exponent = (float)Math.Pow (m_Lacunarity, -inH);
frequency *= m_Lacunarity;
}

if (noise == null)
m_Noise = new Perlin();
else
m_Noise = noise;
}

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 1.0F) weight = 1.0F;
signal = (m_Noise.Noise (x, y) + offset) * m_Exponent;
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;

return result;
}

public float RidgedMultifractal (float x, float y, float offset, float gain)
{
float weight, signal, result;
int i;

signal = Mathf.Abs (m_Noise.Noise (x, y));
signal = offset - signal;
signal *= signal;
result = signal;
weight = 1.0F;

for (i=1;i

Подробнее здесь: https://stackoverflow.com/questions/243 ... ith-layers