/// <summary>
/// precompute atmosphere, normal and vertex data
/// </summary>
public void Precompute()
{
K = Screen.width / (2f * Mathf.Tan((65f / 2f) * Mathf.Deg2Rad));
m_perlin = new ImprovedPerlinNoise(0);
m_perlin.LoadResourcesFor3DNoise();
Texture2D perm = m_perlin.GetPermutationTable2D();
Texture2D grad = m_perlin.GetGradient3D();
VertexComputeShader.SetTexture(0, "_PermTable2D", perm);
VertexComputeShader.SetTexture(0, "_Gradient3D", grad);
mat.SetTexture(PermTable2D, perm);
mat.SetTexture(Gradient3D, grad);
VertexComputeBuffer = new ComputeBuffer((ChunkSegments + 2) * (ChunkSegments + 2), 12);
NormalComputeBuffer = new ComputeBuffer((ChunkSegments + 2) * (ChunkSegments + 2), 12);
PlanetMapCreatorBuffer = new ComputeBuffer(1024 * 1024, 32);
VertexComputeShader.SetBuffer(0, "vertexBuffer", VertexComputeBuffer);
VertexComputeShader.SetBuffer(0, "normalBuffer", NormalComputeBuffer);
PlanetMapGeneratorShader.SetBuffer(0, "Output", PlanetMapCreatorBuffer);
PlanetMapGeneratorShader.SetTexture(0, "_PermTable2D", perm);
PlanetMapGeneratorShader.SetTexture(0, "_Gradient3D", grad);
UpdateNoise();
}
void Start()
{
m_perlin = new ImprovedPerlinNoise(m_seed);
m_perlin.LoadResourcesFor3DNoise();
GetComponent <Renderer>().material.SetTexture("_PermTable2D", m_perlin.GetPermutationTable2D());
GetComponent <Renderer>().material.SetTexture("_Gradient3D", m_perlin.GetGradient3D());
}
public void StartATL()
{
perlin = new ImprovedPerlinNoise(seed);
perlin.LoadResourcesFor4DNoise();
GetComponent <Renderer>().material.SetTexture("_PermTable1D", perlin.GetPermutationTable1D());
GetComponent <Renderer>().material.SetTexture("_PermTable2D", perlin.GetPermutationTable2D());
GetComponent <Renderer>().material.SetTexture("_Gradient4D", perlin.GetGradient4D());
}
public void Init()
{
DontDestroyOnLoad(this);
noise = new ImprovedPerlinNoise(seed);
noise.LoadResourcesFor3DNoise();
renderer.material.SetTexture("_PermTable2D", noise.GetPermutationTable2D());
renderer.material.SetTexture("_Gradient3D", noise.GetGradient3D());
currentTime = 0;
renderer.material.SetFloat("_Evolution", currentTime);
}
void Update()
{
//must reset mesh verts to 0 each frame.
m_meshBuffer.SetData(new float[SIZE * 7]);
//Make the voxels.
m_perlinNoise.SetInt("_Width", N);
m_perlinNoise.SetInt("_Height", N);
m_perlinNoise.SetFloat("_Frequency", 0.02f);
m_perlinNoise.SetFloat("_Lacunarity", 2.0f);
m_perlinNoise.SetFloat("_Gain", 0.5f);
m_perlinNoise.SetFloat("_Time", Time.time * m_speed);
m_perlinNoise.SetTexture(0, "_PermTable1D", perlin.GetPermutationTable1D());
m_perlinNoise.SetTexture(0, "_PermTable2D", perlin.GetPermutationTable2D());
m_perlinNoise.SetTexture(0, "_Gradient4D", perlin.GetGradient4D());
m_perlinNoise.SetBuffer(0, "_Result", m_noiseBuffer);
m_perlinNoise.Dispatch(0, N / 8, N / 8, N / 8);
//Make the voxel normals.
m_normals.SetInt("_Width", N);
m_normals.SetInt("_Height", N);
m_normals.SetBuffer(0, "_Noise", m_noiseBuffer);
m_normals.SetBuffer(0, "_Result", m_normalsBuffer);
m_normals.Dispatch(0, N / 8, N / 8, N / 8);
//Make the mesh verts
m_marchingCubes.SetInt("_Width", N);
m_marchingCubes.SetInt("_Height", N);
m_marchingCubes.SetInt("_Depth", N);
m_marchingCubes.SetInt("_Border", 1);
m_marchingCubes.SetFloat("_Target", 0.0f);
m_marchingCubes.SetBuffer(0, "_Voxels", m_noiseBuffer);
m_marchingCubes.SetBuffer(0, "_Normals", m_normalsBuffer);
m_marchingCubes.SetBuffer(0, "_Buffer", m_meshBuffer);
m_marchingCubes.SetBuffer(0, "_CubeEdgeFlags", m_cubeEdgeFlags);
m_marchingCubes.SetBuffer(0, "_TriangleConnectionTable", m_triangleConnectionTable);
m_marchingCubes.Dispatch(0, N / 8, N / 8, N / 8);
m_drawBuffer.SetBuffer("_Buffer", m_meshBuffer);
m_drawBuffer.SetPass(0);
var prop = new MaterialPropertyBlock();
for (var i = 0; i < N; i++)
{
prop.SetFloat("_IdOffset", i * N * N * 3 * 5);
Graphics.DrawMesh(m_mesh, transform.localToWorldMatrix, m_drawBuffer, 0, null, 0, prop);
}
}
protected override void Start()
{
base.Start();
if (TerrainNode == null)
{
TerrainNode = transform.parent.GetComponent <TerrainNode>();
}
if (TerrainNode.Body == null)
{
TerrainNode.Body = transform.parent.GetComponentInParent <CelestialBody>();
}
var tileSize = GetTileSize(0);
if ((tileSize - GetBorder() * 2 - 1) % (TerrainNode.Body.GridResolution - 1) != 0)
{
throw new InvalidParameterException("Tile size - border * 2 - 1 must be divisible by grid mesh resolution - 1" + string.Format(": {0}-{1}", tileSize, GetBorder()));
}
var storage = Cache.GetStorage(0) as GPUTileStorage;
if (storage == null)
{
throw new InvalidStorageException("Storage must be a GPUTileStorage");
}
if (storage.FilterMode != FilterMode.Point)
{
throw new InvalidParameterException("GPUTileStorage filter must be point. There will be seams in the terrain otherwise");
}
uniforms = new Uniforms();
Noise = new ImprovedPerlinNoise(UpsampleSettings.Seed);
Noise.LoadResourcesFor3DNoise();
UpSampleMaterial.SetTexture("_PermTable2D", Noise.GetPermutationTable2D());
UpSampleMaterial.SetTexture("_Gradient3D", Noise.GetGradient3D());
}
public void Init()
{
DontDestroyOnLoad (this);
noise = new ImprovedPerlinNoise (seed);
noise.LoadResourcesFor3DNoise ();
renderer.material.SetTexture ("_PermTable2D", noise.GetPermutationTable2D ());
renderer.material.SetTexture ("_Gradient3D", noise.GetGradient3D ());
currentTime = 0;
renderer.material.SetFloat ("_Evolution", currentTime);
}