private void Generate2DPerlinNoise(int seed)
{
PerlinNoiseGenerater noiseGenerator = new PerlinNoiseGenerater(seed, PerlinNoiseGenerater.Continum.X, _length, _width, _octaves, _lacunarity, _persistance);
Color[] colors = new Color[_size * _size];
for (int y = 0; y < _size; y++)
{
for (int x = 0; x < _size; x++)
{
colors[x + y * _size] = Color.Lerp(Color.white, Color.black, noiseGenerator.SampleAt(x / (float)_size, y / (float)_size));
}
}
if (!_renderer)
{
_renderer = GameObject.CreatePrimitive(PrimitiveType.Plane).GetComponent <MeshRenderer>();
}
Texture2D texture = new Texture2D(_size, _size);
texture.SetPixels(colors);
texture.Apply();
_renderer.transform.position = Vector3.zero;
_renderer.transform.localRotation = Quaternion.Euler(-90, 0, 0);
_renderer.transform.localScale = new Vector3(1000, 1, 1000);
_renderer.sharedMaterial.mainTexture = texture;
}
public void Draw(WorldMap worldMap, int seed, int ocataves, float lacunarity, float persistance)
{
_worldMap = worldMap;
float _tileSize = 10;
//worldMap.Foreach(delegate (WorldMapTile tile)
//{
// DrawMapTile(tile, _vertices, _colors, _uvs, _indices, _tileSize);
//});
RandomNumberGenerator rng = new RandomNumberGenerator(seed);
PerlinNoiseGenerater heightGenerator = new PerlinNoiseGenerater(rng.GenerateRandomInt(), PerlinNoiseGenerater.Continum.X, Mathf.CeilToInt(length * 10 * 0.05f), Mathf.CeilToInt(width * 10 * 0.05f), ocataves, lacunarity, persistance);
for (int y = 0; y < width; y++)
{
for (int x = -(y / 2); x < length - (y / 2); x++)
{
DrawHexagonAt(WorldMap.ToWorldCoordinates(x, y, _tileSize), heightGenerator, _vertices, _colors, _uvs, _indices, _tileSize);
}
}
_mesh.Clear();
_mesh.SetVertices(_vertices);
_mesh.SetColors(_colors);
_mesh.SetUVs(0, _uvs);
_mesh.SetTriangles(_indices, 0);
_mesh.RecalculateNormals();
_meshFilter.mesh = _mesh;
}
public void Combined()
{
XNAGame game = new XNAGame();
game.SpectaterCamera.FarClip = 10000;
PerlinNoiseGenerater noise;
PerlinNoiseGenerater colorNoise;
noise = new PerlinNoiseGenerater();
colorNoise = new PerlinNoiseGenerater();
float frequency = 0.5f;
///float factor = 0.02f;
float scale = 100f;
List <Vector3> positions = new List <Vector3>();
List <Color> colors = new List <Color>();
int width = 5000;
int height = 5000;
float verticesPerMeter = 0.1f;
int verticesX = (int)(width * verticesPerMeter);
int verticesY = (int)(height * verticesPerMeter);
SimpleTerrain terrain;
noise.NumberOfOctaves = 4;
noise.persistance = 0.5f;
for (int i = 0; i < verticesX; i++)
{
for (int j = 0; j < verticesY; j++)
{
// combinedFractalBrowning (float x,float y,int octaves,float lacunarityFractal,float lacunarityRidge,float gainFractal,float gainRidge,float offset,float distribution )
float zValue = noise.CombinedFractalBrowningAndRidgedMF(i / verticesPerMeter, j / verticesPerMeter, 8, 4, 4, 0.3f, 0.2f, 1.2f, 0.8f) * scale;
positions.Add(new Vector3(i / verticesPerMeter, zValue, j / verticesPerMeter));
colors.Add(heightColoring(zValue, j + i * verticesX));
//colors.Add(new Color((byte)(150 * colorNoise.interpolatedNoise(i * frequency, j * frequency)), (byte)(100 + 70 * colorNoise.interpolatedNoise((i + 1) * frequency, (j + 1) * frequency)), (byte)(140 * colorNoise.interpolatedNoise(i * frequency, (j + 2) * frequency))));
}
}
terrain = new SimpleTerrain(game, positions, colors, verticesX, verticesY);
game.InitializeEvent +=
delegate
{
terrain.CreateRenderData();
};
game.DrawEvent +=
delegate
{
terrain.Render();
};
game.Run();
}
public void FirstNoiseTest()
{
XNAGame game = new XNAGame();
PerlinNoiseGenerater noise;
noise = new PerlinNoiseGenerater();
float factor = 0.1f;
float scale = 15f;
List <Vector3> positions = new List <Vector3>();
int width = 500;
int height = 500;
float verticesPerMeter = 0.5f;
int verticesX = (int)(width * verticesPerMeter);
int verticesY = (int)(height * verticesPerMeter);
game.InitializeEvent +=
delegate
{
noise.NumberOfOctaves = 2;
noise.persistance = 0.5f;
for (int i = 0; i < verticesX; i++)
{
for (int j = 0; j < verticesY; j++)
{
positions.Add(new Vector3(i / verticesPerMeter, noise.GetPerlineNoise(i * factor, j * factor) * scale, j / verticesPerMeter));
}
}
};
game.DrawEvent +=
delegate
{
for (int j = 0; j < verticesY - 1; j++)
{
for (int i = 0; i < verticesX - 1; i++)
{
game.LineManager3D.AddLine(positions[i + j * verticesY], positions[i + j * verticesY + 1], Color.Blue);
game.LineManager3D.AddLine(positions[i + j * verticesY], positions[i + (j + 1) * verticesY], Color.Blue);
game.LineManager3D.AddLine(positions[i + j * verticesY + 1], positions[i + (j + 1) * verticesY], Color.Blue);
}
}
};
game.Run();
}
private HexGrid <float> GenerateHeightMap(int length, int width, int continents, float seaLevel, float frequency, int octaves)
{
HexGrid <float> heightMap = new HexGrid <float>(length, width);
PerlinNoiseGenerater oceanGenerator = new PerlinNoiseGenerater(rng.GenerateRandomInt(), PerlinNoiseGenerater.Continum.X, 2 + continents, 2 + continents);
PerlinNoiseGenerater heightGenerator = new PerlinNoiseGenerater(rng.GenerateRandomInt(), PerlinNoiseGenerater.Continum.X, Mathf.CeilToInt(length * frequency), Mathf.CeilToInt(width * frequency), octaves, 2, 0.5f);
float maxX = Mathf.Sqrt(3) * _tileSize * (length - 1);
float maxZ = 1.5f * _tileSize * (width - 1);
heightMap.For(delegate(int x, int y)
{
Vector3 worldCoordinates = WorldMap.ToWorldCoordinates(x, y, _tileSize);
float randomValue = oceanGenerator.SampleAt(Mathf.InverseLerp(0, maxX, worldCoordinates.x), Mathf.InverseLerp(0, maxZ, worldCoordinates.z), 0, 100);
heightMap[x, y] = (randomValue > 45 - seaLevel && randomValue < 55 + seaLevel ? -1 : 1) * heightGenerator.SampleAt(Mathf.InverseLerp(0, Mathf.Sqrt(3) * _tileSize * (length - 1), worldCoordinates.x), Mathf.InverseLerp(0, 1.5f * _tileSize * (width - 1), worldCoordinates.z), 0, 100);
});
return(heightMap);
}
public void NoiseTestRidgeMF()
{
XNAGame game = new XNAGame();
PerlinNoiseGenerater noise;
noise = new PerlinNoiseGenerater();
float factor = 0.02f;
float scale = 40f;
List <Vector3> positions = new List <Vector3>();
List <Color> colors = new List <Color>();
int width = 300;
int height = 300;
float verticesPerMeter = 0.5f;
int verticesX = (int)(width * verticesPerMeter);
int verticesY = (int)(height * verticesPerMeter);
SimpleTerrain terrain;
noise.NumberOfOctaves = 4;
noise.persistance = 0.5f;
for (int i = 0; i < verticesX; i++)
{
for (int j = 0; j < verticesY; j++)
{
positions.Add(new Vector3(i / verticesPerMeter, noise.RidgedMF((i * 0.2f) / verticesPerMeter, (j * 0.2f) / verticesPerMeter, 0.08f, 8, 4.0f, 0.3f, 1.2f) * scale, j / verticesPerMeter));
colors.Add(new Color((byte)(150 * noise.GetPerlineNoise(i, j)), (byte)(100 + 70 * noise.GetPerlineNoise(i + 1, j + 1)), (byte)(140 * noise.GetPerlineNoise(i, j + 2))));
}
}
terrain = new SimpleTerrain(game, positions, colors, verticesX, verticesY);
game.InitializeEvent +=
delegate
{
terrain.CreateRenderData();
};
game.DrawEvent +=
delegate
{
terrain.Render();
};
game.Run();
}
private HexGrid <float> GenerateBiomeMap(int length, int width, float temperature, float surfaceFrequency, int surfaceOctaves, float forestFrequency, int forestOctaves)
{
HexGrid <float> biomeMap = new HexGrid <float>(length, width);
float maxX = Mathf.Sqrt(3) * _tileSize * (length - 1);
float maxZ = 1.5f * _tileSize * (width - 1);
PerlinNoiseGenerater surfaceGenerator = new PerlinNoiseGenerater(rng.GenerateRandomInt(), PerlinNoiseGenerater.Continum.X, Mathf.CeilToInt(length * surfaceFrequency), Mathf.CeilToInt(width * surfaceFrequency), surfaceOctaves, 2, 0.5f);
PerlinNoiseGenerater forestGenerator = new PerlinNoiseGenerater(rng.GenerateRandomInt(), PerlinNoiseGenerater.Continum.X, Mathf.CeilToInt(length * forestFrequency), Mathf.CeilToInt(width * forestFrequency), forestOctaves, 2, 0.5f);
biomeMap.For(delegate(int x, int y)
{
Vector3 worldCoordinates = WorldMap.ToWorldCoordinates(x, y, _tileSize);
float latitude = Math.Abs(WorldMap.ToGeographicCoordinates(x, y, length, width).y * 2f / width);
float randomValue = surfaceGenerator.SampleAt(Mathf.InverseLerp(0, maxX, worldCoordinates.x), Mathf.InverseLerp(0, maxZ, worldCoordinates.z), 0, 100);
biomeMap[x, y] = randomValue > Mathf.Lerp(50 - temperature, 80, MathUtility.CubicCurve2(latitude)) ? 0 : (randomValue < Mathf.Lerp(20 - 2 * temperature, 100, MathUtility.CubicCurve1(latitude)) ? -1 : 1) * forestGenerator.SampleAt(Mathf.InverseLerp(0, maxX, worldCoordinates.x), Mathf.InverseLerp(0, maxZ, worldCoordinates.z), 0, 100);
});
return(biomeMap);
}
public Array2D <float> GenerateBottomIslandHeightmap(int size)
{
PerlinNoiseGenerater noise;
noise = new PerlinNoiseGenerater();
float factor = 0.1f;
float scale = 10f;
List <Vector3> positions = new List <Vector3>();
List <Color> colors = new List <Color>();
List <Vector3> positionsIsland = new List <Vector3>();
List <Color> colorsIsland = new List <Color>();
List <Vector3> positionsFinal = new List <Vector3>();
List <Color> colorsFinal = new List <Color>();
int width = size;
int height = size;
float lengthFactor = 0.2f;
SimpleTerrain terrain;
SimpleTerrain terrainIsland;
SimpleTerrain terrainFinal;
ProceduralHeigthGenerater gen = new ProceduralHeigthGenerater(8, 0.7f);
float heigestFBM = 0;
float heigestRidge = 0;
float lowestIsland = 0;
var heights = new Array2D <float>(new Point2(width, height));
float[,] heightDataRidge = new float[width, height];
float[,] heightDataFBM = new float[width, height];
float[,] heightDataIsland = new float[width, height];
float[,] heightDataFinal = new float[width, height];
var r = random;
var octaves = new[]
{
//new Vector4(1/2f, 0.5f, (float)r.NextDouble(), (float)r.NextDouble()),
//new Vector4(1/5f, 2, (float)r.NextDouble(), (float)r.NextDouble()),
//new Vector4(1/10f, 5f, (float)r.NextDouble(), (float)r.NextDouble()),
//new Vector4(1f, 1f, (float)r.NextDouble(), (float)r.NextDouble()),
new Vector4(1 / 2f, 1f, (float)r.NextDouble(), (float)r.NextDouble()),
new Vector4(1 / 5f, 4, (float)r.NextDouble(), (float)r.NextDouble()),
new Vector4(1 / 10f, 10f, (float)r.NextDouble(), (float)r.NextDouble()),
};
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
noise.NumberOfOctaves = 1;
//heights[new Point2(i, j)] += noise.RidgedMF(i * lengthFactor, j * lengthFactor, 0.15f, 8, 2f, 0.7f, 0.8f);//noise.CombinedFractalBrowningAndRidgedMF(i * lengthFactor, j * lengthFactor, 8, 4,5f, 0.5f, 2f, 0.8f, 1f);
foreach (var v in octaves)
{
float frequency = v.X;
float oScale = v.Y;
Vector2 offset = new Vector2(v.Z, v.W) * 1000;
heights[new Point2(i, j)] += noise.GetPerlineNoise((i + offset.X) * frequency, (j + offset.Y) * frequency) * oScale;
}
heightDataFBM[i, j] = noise.GetFractalBrowningNoise(i * lengthFactor, j * lengthFactor, 8, 1.2f, 1.9f, 1.2f);
heightDataIsland[i, j] = gen.IslandFactor(i * lengthFactor, j * lengthFactor, new Vector2(width * lengthFactor * 0.5f, height * lengthFactor * 0.5f), width * lengthFactor * 0.42f, width * lengthFactor * 0.4f);//noise.CombinedFractalBrowningAndRidgedMF(i, j, 8, 4, 4, 0.9f, 0.5f, 1.2f, 0.8f)*0.1f+gen.IslandFactor(i, j, new Vector2(width * 0.45f, height * 0.5f),0,width*0.22f)*0.9f ;
if (heigestFBM < heightDataFBM[i, j])
{
heigestFBM = heightDataFBM[i, j];
}
if (heigestRidge < heightDataRidge[i, j])
{
heigestRidge = heightDataRidge[i, j];
}
if (lowestIsland > heightDataIsland[i, j])
{
lowestIsland = heightDataIsland[i, j];
}
}
}
return(heights);
}
public static void generateTerrain(int chunksX, int chunksY)
{
PerlinNoiseGenerater noise;
noise = new PerlinNoiseGenerater();
float factor = 0.1f;
float scale = 1f;
List <Vector3> positions = new List <Vector3>();
List <Vector3> positionsbase = new List <Vector3>();
List <Vector3> positionsbaseDifference = new List <Vector3>();
List <Color> colors = new List <Color>();
List <Color> colorsbase = new List <Color>();
int width = chunksX * 16;
int height = chunksY * 16;
SimpleTerrain terrain;
SimpleTerrain terrainbase;
SimpleTerrain terrainbaseDiffernce;
ProceduralHeigthGenerater gen = new ProceduralHeigthGenerater(8, 0.7f);
float[,] heightData = new float[width, height];
float[,] heightDataErrosion = new float[width, height];
//float[,] heightDataErrosionDiffernce = new float[width, height];
for (int i = 0; i < (int)(width); i++)
{
for (int j = 0; j < height; j++)
{
heightData[i, j] = (noise.GetPerlineNoise(i, j, 8, 0.1f, 0.8f, 0.8f) * 0.8f + noise.GetPerlineNoise(noise.Perturb(i, j, 0.1f, 30).X, noise.Perturb(i, j, 0.1f, 30).Y, 4, 0.2f, 0.5f, 0.5f) * 0.25f) * 70;
}
}
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
positionsbase.Add(new Vector3(i, heightData[i, j], j));
colorsbase.Add(Color.White);
}
}
//heightDataErrosionDiffernce = heightData
heightDataErrosion = gen.GenerateHydrolicErrosion(heightData, 50 * width * height, width, height);
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
positions.Add(new Vector3(i, heightDataErrosion[i, j], j));
colors.Add(new Color(new Microsoft.Xna.Framework.Vector3(positions[i * width + j].Y - positionsbase[i * width + j].Y, 50, 50)));
//positionsbaseDifference.Add(new Vector3(i, positions[i * width + j].Y - positionsbase[i * width + j].Y, j));(
}
}
for (int x = 0; x < chunksX; x++)
{
for (int y = 0; y < chunksY; y++)
{
var terr = new VoxelTerrainChunk();
terr.Size = new Point3(16, 64, 16);
//terr.Size = new Point3(5, 5, 5);
terr.WorldPosition = Vector3.Modulate(terr.Size.ToVector3() * terr.NodeSize, new Vector3(x, 0, y));
terr.Create();
TW.Data.GetSingleton <Datastore>().Persist(terr);
for (int tx = 0; tx < terr.Size.X; tx++)
{
for (int ty = 0; ty < terr.Size.Y / 2; ty++)
{
for (int tz = 0; tz < terr.Size.Z; tz++)
{
var heightMapX = tx + (int)terr.WorldPosition.X;
var heightMapZ = tz + (int)terr.WorldPosition.Z;
if (heightMapX >= width || heightMapZ >= height)
{
continue;
}
if (ty < heightDataErrosion[heightMapX, heightMapZ] / 2f)
{
terr.GetVoxelInternal(new Point3(tx, ty, tz)).Filled = true;
}
}
}
}
}
}
}
public void NoiseTestSimpleTerrain()
{
XNAGame game = new XNAGame();
PerlinNoiseGenerater noise;
noise = new PerlinNoiseGenerater();
float factor = 0.1f;
float scale = 10f;
List <Vector3> positions = new List <Vector3>();
List <Color> colors = new List <Color>();
int width = 100;
int height = 100;
float verticesPerMeter = 1;
int verticesX = (int)(width * verticesPerMeter);
int verticesY = (int)(height * verticesPerMeter);
SimpleTerrain terrain;
noise.NumberOfOctaves = 8;
noise.persistance = 0.2f;
for (int i = 0; i < verticesX; i++)
{
for (int j = 0; j < verticesY; j++)
{
positions.Add(new Vector3(i / verticesPerMeter, noise.interpolatedNoise((i / verticesPerMeter) * 0.1f, (j / verticesPerMeter) * 0.2f) * scale, j / verticesPerMeter));
colors.Add(new Color((byte)(150 * noise.GetPerlineNoise(i, j)), (byte)(100 + 70 * noise.GetPerlineNoise(i + 1, j + 1)), (byte)(140 * noise.GetPerlineNoise(i, j + 2))));
}
}
terrain = new SimpleTerrain(game, positions, colors, verticesX, verticesY);
game.InitializeEvent +=
delegate
{
terrain.CreateRenderData();
};
bool changed = false;
game.UpdateEvent +=
delegate
{
if (game.Keyboard.IsKeyPressed(Microsoft.Xna.Framework.Input.Keys.O))
{
noise.NumberOfOctaves++;
changed = true;
}
if (game.Keyboard.IsKeyPressed(Microsoft.Xna.Framework.Input.Keys.P))
{
noise.persistance *= 0.1f;
changed = true;
}
if (game.Keyboard.IsKeyPressed(Microsoft.Xna.Framework.Input.Keys.F))
{
factor *= 0.1f;
changed = true;
}
if (changed)
{
for (int i = 0; i < verticesX; i++)
{
for (int j = 0; j < verticesY; j++)
{
positions.Add(new Vector3(i / verticesPerMeter, noise.GetPerlineNoise((i / verticesPerMeter) * factor, (j / verticesPerMeter) * factor) * scale, j / verticesPerMeter));
colors.Add(new Color((byte)(150 * noise.GetPerlineNoise(i, j)), (byte)(100 + 70 * noise.GetPerlineNoise(i + 1, j + 1)), (byte)(140 * noise.GetPerlineNoise(i, j + 2))));
}
}
terrain = new SimpleTerrain(game, positions, colors, verticesX, verticesY);
terrain.CreateRenderData();
changed = false;
}
};
game.DrawEvent +=
delegate
{
terrain.Render();
};
game.Run();
}
//private void DrawMapTile(WorldMapTile tile, List<Vector3> vertices, List<Color> colors, List<Vector2> uvs, List<int> indices, float tileSize)
//{
// DrawHexagonAt(WorldMap.ToWorldCoordinates(tile.axialCoordinates, tileSize), vertices, colors, uvs, indices, tileSize);
//}
private void DrawHexagonAt(Vector3 center, PerlinNoiseGenerater heightMap, List <Vector3> vertices, List <Color> colors, List <Vector2> uvs, List <int> indices, float size)
{
int centerIndex = vertices.Count;
float centerH = heightMap.SampleAt(Mathf.InverseLerp(0, 4000, center.x), Mathf.InverseLerp(0, 2000, center.z));
vertices.Add(Elevate(center, centerH));
Color c = GetSurfaceColor(center, centerH);
//Debug.Log(c);
colors.Add(c);
uvs.Add(new Vector2(center.x / 100, center.z / 100));
for (int i = 0; i < 6; i++)
{
Vector3 position = center + size / 2 * new Vector3(Mathf.Sin(i * DEG_60), 0, Mathf.Cos(i * DEG_60));
float h = heightMap.SampleAt(Mathf.InverseLerp(0, 4000, position.x), Mathf.InverseLerp(0, 2000, position.z));
vertices.Add(Elevate(position, h));
colors.Add(GetSurfaceColor(position, h));
uvs.Add(new Vector2(position.x / 100, position.z / 100));
indices.Add(centerIndex);
indices.Add(centerIndex + 1 + i);
indices.Add(centerIndex + 1 + (i + 1) % 6);
}
for (int i = 0; i < 6; i++)
{
Vector3 position1 = center + size * new Vector3(Mathf.Sin(i * DEG_60), 0, Mathf.Cos(i * DEG_60));
Vector3 position2 = center + size * Mathf.Cos(DEG_30) * new Vector3(Mathf.Sin(DEG_30 + i * DEG_60), 0, Mathf.Cos(DEG_30 + i * DEG_60));
float h1 = heightMap.SampleAt(Mathf.InverseLerp(0, 4000, position1.x), Mathf.InverseLerp(0, 2000, position1.z));
float h2 = heightMap.SampleAt(Mathf.InverseLerp(0, 4000, position2.x), Mathf.InverseLerp(0, 2000, position2.z));
vertices.Add(Elevate(position1, h1));
vertices.Add(Elevate(position2, h2));
colors.Add(GetSurfaceColor(position1, h1));
colors.Add(GetSurfaceColor(position2, h2));
uvs.Add(new Vector2(position1.x / 100, position1.z / 100));
uvs.Add(new Vector2(position2.x / 100, position2.z / 100));
indices.Add(centerIndex + 7 + i * 2 + 1);
indices.Add(centerIndex + 1 + i);
indices.Add(centerIndex + 7 + i * 2);
indices.Add(centerIndex + 7 + i * 2 + 1);
indices.Add(centerIndex + 1 + (i + 1) % 6);
indices.Add(centerIndex + 1 + i);
indices.Add(centerIndex + 7 + i * 2 + 1);
indices.Add(centerIndex + 7 + (i * 2 + 2) % 12);
indices.Add(centerIndex + 1 + (i + 1) % 6);
}
//for (int i = 0; i < 6; i++)
//{
// Vector3 position1 = center + size * new Vector3(Mathf.Sin(i * DEG_60), 0, Mathf.Cos(i * DEG_60));
// Vector3 position2 = center + size * Mathf.Cos(DEG_30) / Mathf.Cos(DEG_10) * new Vector3(Mathf.Sin(DEG_20 + i * DEG_60), 0, Mathf.Cos(DEG_20 + i * DEG_60));
// Vector3 position3 = center + size * Mathf.Cos(DEG_30) / Mathf.Cos(DEG_10) * new Vector3(Mathf.Sin(DEG_40 + i * DEG_60), 0, Mathf.Cos(DEG_40 + i * DEG_60));
// vertices.Add(AddHeight(position1, heightMap));
// vertices.Add(AddHeight(position2, heightMap));
// vertices.Add(AddHeight(position3, heightMap));
// //if (tile.biome == 0)
// // colors.Add(new Color(1, 1, 1));
// //else
// // colors.Add(new Color(0, 0, 0));
// uvs.Add(new Vector2(position1.x / 100, position1.z / 100));
// uvs.Add(new Vector2(position2.x / 100, position2.z / 100));
// uvs.Add(new Vector2(position3.x / 100, position3.z / 100));
// indices.Add(centerIndex + 19 + i * 3 + 1);
// indices.Add(centerIndex + 7 + i * 2);
// indices.Add(centerIndex + 19 + i * 3);
// indices.Add(centerIndex + 19 + i * 3 + 1);
// indices.Add(centerIndex + 7 + i * 2 + 1);
// indices.Add(centerIndex + 7 + i * 2);
// indices.Add(centerIndex + 19 + i * 3 + 1);
// indices.Add(centerIndex + 19 + i * 3 + 2);
// indices.Add(centerIndex + 7 + i * 2 + 1);
// indices.Add(centerIndex + 19 + i * 3 + 2);
// indices.Add(centerIndex + 7 + (i * 2 + 2) % 12);
// indices.Add(centerIndex + 7 + i * 2 + 1);
// indices.Add(centerIndex + 19 + i * 3 + 2);
// indices.Add(centerIndex + 19 + (i * 3 + 3) % 18);
// indices.Add(centerIndex + 7 + (i * 2 + 2) % 12);
//}
}
