void Start()
{
voxelGenerator = GetComponent <VoxelGenerator>();
terrainArray = new int[chunkSize, chunkSize, chunkSize];
voxelGenerator.Initialise();
networkView = GetComponent <NetworkView>();
if (Application.loadedLevelName == "Scene3")
{
if (!networkView.isMine)
{
networkView.RPC("RequestTerrain", networkView.owner, Network.player);
}
else
{
InitialiseTerrain();
CreateTerrain();
voxelGenerator.UpdateMesh();
}
}
else
{
InitialiseTerrain();
CreateTerrain();
voxelGenerator.UpdateMesh();
}
}
public void EmptyChunk(Vector3 center, Vector3 posInWorld, int w, int h, int l, float blockSize)
{
this.center = center;
this.posInWorld = posInWorld;
blocks = new Block[w, h, l];
neighbors = new Chunk[6];
vGen = GameObject.FindObjectOfType <VoxelGenerator>();
}
void Start()
{
float scale;
l0 = VoxelGenerator.CreateBoxScaled(0.05f, 0.001f, 0.05f, 10, 1, out scale);
l1 = VoxelGenerator.CreateSphereScaled(0.02f, 10, 1, out scale);
l2 = VoxelGenerator.CreateCapsuleScaled(0.02f, 0.04f, 10, 1, out scale);
}
private void ChunkMeshDataThread(Action <ChunkData> callback, Vector3 pos)
{
ChunkData data = new VoxelGenerator().GenerateChunk(pos);
lock (chunkDataInfoQueue)
{
chunkDataInfoQueue.Enqueue(new ChunkThreadInfo <ChunkData>(callback, data));
}
}
private void ChunkUpdateThread(Action <ChunkData> callback, Vector3 pos)
{
ChunkData data = new VoxelGenerator().GenerateChunkByVoxelCube(pos, WorldChunk[pos].Cubes);
lock (ChunkThreadUpdateDataInfoQueue)
{
ChunkThreadUpdateDataInfoQueue.Enqueue(new ChunkThreadInfo <ChunkData>(callback, data));
}
}
public Chunk(Vector3 c, Vector3 p, int w, int h, int l, float blockSize)
{
center = c;
posInWorld = p;
blocks = new Block[w, h, l];
neighbors = new Chunk[6];
vGen = GameObject.FindObjectOfType <VoxelGenerator>();
CreateBlocks(w, h, l, blockSize);
}
void Start()
{
voxelGenerator = GetComponent <VoxelGenerator>();
// Instantiate the array with size based on chunksize
terrainArray = new int[chunkSize, chunkSize, chunkSize];
voxelGenerator.Initialise();
InitialiseTerrain();
CreateTerrain();
voxelGenerator.UpdateMesh();
}
// Use this for initialization
void Start()
{
voxelGenerator = GetComponent <VoxelGenerator>();
terrainArray = new int[chunkSize, chunkSize, chunkSize];
voxelGenerator.Initialise();
InitialiseTerrain();
CreateTerrain();
voxelGenerator.UpdateMesh();
blockToPlace = 1;
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
VoxelGenerator voxelGenerator = (VoxelGenerator)target;
if (GUILayout.Button("Build Mesh"))
{
voxelGenerator.BuildMesh();
}
}
public void InitialiseChunk(string filename)
{
voxelGenerator = GetComponent <VoxelGenerator>();
terrainArray = new int[chunkSize, chunkSize, chunkSize];
voxelGenerator.Initialise();
InitialiseTerrain();
CreateTerrain();
voxelGenerator.UpdateMesh();
}
// Use this for initialization
void Start()
{
voxelGenerator = GetComponent <VoxelGenerator>();
terrainArray = new int[chunkSize, chunkSize, chunkSize];
voxelGenerator.Initialise();
InitialiseTerrain();
terrainArray = XMLVoxelFileWriter.LoadChunkFromXMLFile(16, "AssessmentChunk1");
CreateTerrain();
voxelGenerator.UpdateMesh();
}
private void Awake() //when ovject is instanciated start doesn't run first
{
voxelGenerator = GetComponent <VoxelGenerator>();
terrainArray = new int[chunkSize, chunkSize, chunkSize];
voxelGenerator.Initialise();
LoadVoxelChunk();
Debug.Log(start);
CreateTerrain();
voxelGenerator.UpdateMesh();
}
void Start()
{
voxelGenerator = GetComponent <VoxelGenerator>();
terrainArray = new int[chunkSize, chunkSize, chunkSize];
loadPanel = GameObject.Find("LoadPanel");
loadFileName = loadPanel.GetComponentInChildren <InputField>();
voxelGenerator.Initialise();
InitialiseTerrain();
CreateTerrain();
voxelGenerator.UpdateMesh();
PlayerScript.OnEventSetBlock += SetBlock;
player = GameObject.Find("Player");
loadPanel.SetActive(false);
panelOpen = false;
LockCursor();
}
// Use this for initialization
void Start()
{
// find the voxel generator script
voxelGenerator = GetComponent <VoxelGenerator>();
// find the name of the texture
switch (blockTex)
{
case 1:
blockTexName = "Grass";
break;
case 2:
blockTexName = "Dirt";
break;
case 3:
blockTexName = "Sand";
break;
case 4:
blockTexName = "Stone";
break;
default:
blockTexName = "Grass";
break;
}
// create the voxel and texture it
voxelGenerator.Initialise();
voxelGenerator.CreateVoxel(0, 0, 0, blockTexName);
voxelGenerator.UpdateMesh();
// find the rigidbody and the player object
rb = GetComponent <Rigidbody>();
player = GameObject.Find("Player");
}
//Initialise the terrain*****************************************************************************************************************************************************
void Start()
{
Pathfinder.traversalBegin += CantSetBlocks;
Pathfinder.traversalEnd += CanSetBlocks;
voxelGenerator = GetComponent <VoxelGenerator>();
terrainArray = new int[chunkSize, chunkSize, chunkSize];
voxelGenerator.Initialise();
InitialiseTerrain();
//get terrainArray from xml
terrainArray = XMLVoxelFileWriter.LoadChunkFromXMLFile(16, "AssessmentChunk2");
CreateTerrain();
voxelGenerator.UpdateMesh();
wayPointList = new List <Vector3>();
for (int x = 0; x < terrainArray.GetLength(0); x++)
{
for (int y = 0; y < terrainArray.GetLength(1); y++)
{
for (int z = 0; z < terrainArray.GetLength(2); z++)
{
if (terrainArray[x, y, z] == 3)
{
wayPointList.Add(new Vector3(x + 0.5f, y + 1.5f, z + 0.5f));
}
}
}
}
}
bool GenerateTiles(
MapDataStore data,
out CPUMesh tiles,
out CPUMesh stencilTiles,
out CPUMesh transparentTiles,
out CPUMesh topTiles,
out CPUMesh topStencilTiles,
out CPUMesh topTransparentTiles,
out CPUMesh collisionTiles,
out CPUMesh terrainTiles,
out CPUMesh topTerrainTiles)
{
int block_x = data.SliceOrigin.x / GameMap.blockSize;
int block_y = data.SliceOrigin.y / GameMap.blockSize;
int block_z = data.SliceOrigin.z;
int bufferIndex = 0;
int stencilBufferIndex = 0;
int transparentBufferIndex = 0;
int collisionIndex = 0;
int terrainIndex = 0;
GameMap.BeginSample("Fill Mesh Buffer");
for (int i = 0; i < (int)MeshLayer.Count; i++)
{
for (int xx = (block_x * GameMap.blockSize); xx < (block_x + 1) * GameMap.blockSize; xx++)
{
for (int yy = (block_y * GameMap.blockSize); yy < (block_y + 1) * GameMap.blockSize; yy++)
{
if (!data.InSliceBounds(new DFCoord(xx, yy, block_z)))
{
throw new UnityException("OOB");
}
if (data[xx, yy, block_z] == null)
{
continue;
}
if (i < (int)MeshLayer.StaticCutout)
{
FillMeshBuffer(
out meshBuffer[bufferIndex],
(MeshLayer)i,
data[xx, yy, block_z],
GameMap.DFtoUnityCoord(xx - (block_x * GameMap.blockSize),
yy - (block_y * GameMap.blockSize),
-GameMap.MapZOffset));
bufferIndex++;
}
else if (i < (int)MeshLayer.StaticTransparent)
{
FillMeshBuffer(
out stencilMeshBuffer[stencilBufferIndex],
(MeshLayer)i,
data[xx, yy, block_z],
GameMap.DFtoUnityCoord(xx - (block_x * GameMap.blockSize),
yy - (block_y * GameMap.blockSize),
-GameMap.MapZOffset));
stencilBufferIndex++;
}
else if (i < (int)MeshLayer.Collision)
{
FillMeshBuffer(
out transparentMeshBuffer[transparentBufferIndex],
(MeshLayer)i,
data[xx, yy, block_z],
GameMap.DFtoUnityCoord(xx - (block_x * GameMap.blockSize),
yy - (block_y * GameMap.blockSize),
-GameMap.MapZOffset));
transparentBufferIndex++;
}
else if (i < (int)MeshLayer.NaturalTerrain)
{
FillMeshBuffer(
out collisionMeshBuffer[collisionIndex],
(MeshLayer)i,
data[xx, yy, block_z],
GameMap.DFtoUnityCoord(xx - (block_x * GameMap.blockSize),
yy - (block_y * GameMap.blockSize),
-GameMap.MapZOffset));
collisionIndex++;
}
else if (i == (int)MeshLayer.NaturalTerrain)
{
FillMeshBuffer(out terrainMeshBuffer[terrainIndex],
(MeshLayer)i,
data[xx, yy, block_z],
GameMap.DFtoUnityCoord(xx - (block_x * GameMap.blockSize),
yy - (block_y * GameMap.blockSize),
-GameMap.MapZOffset));
terrainIndex++;
}
}
}
}
GameMap.EndSample();
bool dontCare, success;
GameMap.BeginSample("Generate Voxels");
VoxelGenerator voxelGen = new VoxelGenerator();
if (block_z == 0)
{
voxelGen.bottomless = true;
}
var naturalTerrain = voxelGen.Triangulate(data);
GameMap.EndSample();
GameMap.BeginSample("Combine Meshes");
terrainTiles = MeshCombineUtility.ColorCombine(terrainMeshBuffer, out dontCare, false, naturalTerrain);
topTerrainTiles = MeshCombineUtility.ColorCombine(terrainMeshBuffer, out dontCare, true);
stencilTiles = MeshCombineUtility.ColorCombine(stencilMeshBuffer, out dontCare, false);
topStencilTiles = MeshCombineUtility.ColorCombine(stencilMeshBuffer, out dontCare, true);
transparentTiles = MeshCombineUtility.ColorCombine(transparentMeshBuffer, out dontCare, false);
topTransparentTiles = MeshCombineUtility.ColorCombine(transparentMeshBuffer, out dontCare, true);
topTiles = MeshCombineUtility.ColorCombine(meshBuffer, out dontCare, true);
tiles = MeshCombineUtility.ColorCombine(meshBuffer, out success, false);
collisionTiles = MeshCombineUtility.ColorCombine(collisionMeshBuffer, out dontCare, false, naturalTerrain);
GameMap.EndSample();
return(success);
}
public VoxelGeneratorMiniMap(VoxelGenerator generator)
{
m_Generator = generator;
m_Texture = new Texture2D(generator.Dimension.X, generator.Dimension.Y);
m_Texture.wrapMode = TextureWrapMode.Clamp;
}
bool GenerateTiles(MapDataStore data, out CPUMesh tiles, out CPUMesh stencilTiles, out CPUMesh transparentTiles, out CPUMesh topTiles, out CPUMesh topStencilTiles, out CPUMesh topTransparentTiles, out CPUMesh collisionTiles, out CPUMesh terrainTiles, out CPUMesh topTerrainTiles)
{
int block_x = data.SliceOrigin.x / GameMap.blockSize;
int block_y = data.SliceOrigin.y / GameMap.blockSize;
int block_z = data.SliceOrigin.z;
int bufferIndex = 0;
int stencilBufferIndex = 0;
int transparentBufferIndex = 0;
int collisionIndex = 0;
int terrainIndex = 0;
for (int xx = (block_x * GameMap.blockSize); xx < (block_x + 1) * GameMap.blockSize; xx++)
for (int yy = (block_y * GameMap.blockSize); yy < (block_y + 1) * GameMap.blockSize; yy++)
{
if (!data.InSliceBounds(new DFCoord(xx, yy, block_z))) throw new UnityException("OOB");
if (data[xx, yy, block_z] == null) continue;
for (int i = 0; i < (int)MeshLayer.Count; i++)
{
if (i < (int)MeshLayer.StaticCutout)
{
FillMeshBuffer(
out meshBuffer[bufferIndex],
(MeshLayer)i,
data[xx, yy, block_z],
GameMap.DFtoUnityCoord(xx - (block_x * GameMap.blockSize),
yy - (block_y * GameMap.blockSize),
-GameMap.MapZOffset));
bufferIndex++;
}
else if (i < (int)MeshLayer.StaticTransparent)
{
FillMeshBuffer(
out stencilMeshBuffer[stencilBufferIndex],
(MeshLayer)i,
data[xx, yy, block_z],
GameMap.DFtoUnityCoord(xx - (block_x * GameMap.blockSize),
yy - (block_y * GameMap.blockSize),
-GameMap.MapZOffset));
stencilBufferIndex++;
}
else if (i < (int)MeshLayer.Collision)
{
FillMeshBuffer(
out transparentMeshBuffer[transparentBufferIndex],
(MeshLayer)i,
data[xx, yy, block_z],
GameMap.DFtoUnityCoord(xx - (block_x * GameMap.blockSize),
yy - (block_y * GameMap.blockSize),
-GameMap.MapZOffset));
transparentBufferIndex++;
}
else if (i < (int)MeshLayer.NaturalTerrain)
{
FillMeshBuffer(
out collisionMeshBuffer[collisionIndex],
(MeshLayer)i,
data[xx, yy, block_z],
GameMap.DFtoUnityCoord(xx - (block_x * GameMap.blockSize),
yy - (block_y * GameMap.blockSize),
-GameMap.MapZOffset));
collisionIndex++;
}
else if(i == (int)MeshLayer.NaturalTerrain)
{
FillMeshBuffer(out terrainMeshBuffer[terrainIndex],
(MeshLayer)i,
data[xx, yy, block_z],
GameMap.DFtoUnityCoord(xx - (block_x * GameMap.blockSize),
yy - (block_y * GameMap.blockSize),
-GameMap.MapZOffset));
terrainIndex++;
}
}
}
bool dontCare, success;
VoxelGenerator voxelGen = new VoxelGenerator();
if (block_z == 0)
voxelGen.bottomless = true;
terrainTiles = voxelGen.Triangulate(data);
terrainTiles = MeshCombineUtility.ColorCombine(terrainMeshBuffer, out dontCare, false, terrainTiles);
topTerrainTiles = MeshCombineUtility.ColorCombine(terrainMeshBuffer, out dontCare, true);
stencilTiles = MeshCombineUtility.ColorCombine(stencilMeshBuffer, out dontCare, false);
topStencilTiles = MeshCombineUtility.ColorCombine(stencilMeshBuffer, out dontCare, true);
transparentTiles = MeshCombineUtility.ColorCombine(transparentMeshBuffer, out dontCare, false);
topTransparentTiles = MeshCombineUtility.ColorCombine(transparentMeshBuffer, out dontCare, true);
topTiles = MeshCombineUtility.ColorCombine(meshBuffer, out dontCare, true);
tiles = MeshCombineUtility.ColorCombine(meshBuffer, out success, false);
collisionTiles = MeshCombineUtility.ColorCombine(collisionMeshBuffer, out dontCare, false);
return success;
}
/// <summary>
/// This is the function that actually decides what mesh and texture each tile gets
/// </summary>
/// <param name="buffer">Buffer to put the chosen meshes into for combining</param>
/// <param name="layer">layer currently being worked on</param>
/// <param name="tile">The tile to get all the needed info from.</param>
void FillMeshBuffer(out MeshCombineUtility.MeshInstance buffer, MeshLayer layer, MapDataStore.Tile tile, Vector3 pos)
{
buffer = new MeshCombineUtility.MeshInstance();
Vector2 index1 = Vector2.zero;
Vector2 index2 = Vector2.zero;
MeshContent meshContent = null;
buffer.color = Color.grey;
if (layer == MeshLayer.Collision)
{
if (!ContentLoader.Instance.CollisionMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
if (meshContent.MeshData.ContainsKey(MeshLayer.Collision))
{
buffer.meshData = meshContent.MeshData[MeshLayer.Collision];
}
else if (meshContent.MeshData.ContainsKey(MeshLayer.StaticMaterial))
{
buffer.meshData = meshContent.MeshData[MeshLayer.StaticMaterial];
}
else
{
buffer.meshData = null;
return;
}
buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
buffer.hiddenFaces = CalculateHiddenFaces(tile, meshContent.Rotation);
return;
}
//if (layer == MeshLayer.BuildingCollision)
//{
// if (tile.buildingType == default(BuildingStruct) || !ContentLoader.Instance.BuildingCollisionMeshConfiguration.GetValue(tile, layer, out meshContent))
// {
// buffer.meshData = null;
// return;
// }
// if (meshContent.MeshData.ContainsKey(MeshLayer.Collision))
// buffer.meshData = meshContent.MeshData[MeshLayer.Collision];
// else if (meshContent.MeshData.ContainsKey(MeshLayer.BuildingMaterial))
// buffer.meshData = meshContent.MeshData[MeshLayer.BuildingMaterial];
// else if (meshContent.MeshData.ContainsKey(MeshLayer.BuildingMaterialCutout))
// buffer.meshData = meshContent.MeshData[MeshLayer.BuildingMaterialCutout];
// else if (meshContent.MeshData.ContainsKey(MeshLayer.BuildingMaterialTransparent))
// buffer.meshData = meshContent.MeshData[MeshLayer.BuildingMaterialTransparent];
// else
// {
// buffer.meshData = null;
// return;
// }
// buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
// buffer.hiddenFaces = CalculateHiddenFaces(tile, meshContent.Rotation);
// return;
//}
if (ContentLoader.Instance.DesignationMeshConfiguration.GetValue(tile, layer, out meshContent))
{
if (!meshContent.MeshData.ContainsKey(layer))
{
buffer.meshData = null;
return;
}
buffer.meshData = meshContent.MeshData[layer];
buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
if (TextureStorage.UsingArray)
{
if (meshContent.MaterialTexture != null)
{
index1.x = meshContent.MaterialTexture.ArrayIndex;
}
else
{
index1.x = ContentLoader.Instance.DefaultMatTexArrayIndex;
}
if (meshContent.ShapeTexture != null)
{
index1.y = meshContent.ShapeTexture.ArrayIndex;
}
else
{
index1.y = ContentLoader.Instance.DefaultShapeTexArrayIndex;
}
if (meshContent.SpecialTexture != null)
{
index2.x = meshContent.SpecialTexture.ArrayIndex;
}
else
{
index2.x = ContentLoader.Instance.DefaultSpecialTexArrayIndex;
}
buffer.uv1Transform = Matrix4x4.identity;
buffer.uv2Force = index1;
buffer.uv3Force = index2;
}
else
{
if (meshContent.MaterialTexture != null)
{
buffer.uv1Transform = meshContent.MaterialTexture.UVTransform;
}
else
{
buffer.uv1Transform = ContentLoader.Instance.DefaultMatTexTransform;
}
if (meshContent.ShapeTexture != null)
{
buffer.uv2Transform = meshContent.ShapeTexture.UVTransform;
}
else
{
buffer.uv2Transform = ContentLoader.Instance.DefaultShapeTexTransform;
}
if (meshContent.SpecialTexture != null)
{
buffer.uv3Transform = meshContent.SpecialTexture.UVTransform;
}
else
{
buffer.uv3Transform = ContentLoader.Instance.DefaultSpecialTexTransform;
}
}
buffer.hiddenFaces = CalculateHiddenFaces(tile, meshContent.Rotation);
return;
}
switch (layer)
{
case MeshLayer.GrowthMaterial:
case MeshLayer.GrowthMaterial1:
case MeshLayer.GrowthMaterial2:
case MeshLayer.GrowthMaterial3:
case MeshLayer.GrowthCutout:
case MeshLayer.GrowthCutout1:
case MeshLayer.GrowthCutout2:
case MeshLayer.GrowthCutout3:
case MeshLayer.GrowthTransparent:
case MeshLayer.GrowthTransparent1:
case MeshLayer.GrowthTransparent2:
case MeshLayer.GrowthTransparent3:
{
switch (tile.tiletypeMaterial)
{
case TiletypeMaterial.PLANT:
case TiletypeMaterial.ROOT:
case TiletypeMaterial.TREE_MATERIAL:
case TiletypeMaterial.MUSHROOM:
if (!ContentLoader.Instance.GrowthMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
break;
default:
buffer.meshData = null;
return;
}
}
break;
//case MeshLayer.BuildingMaterial:
//case MeshLayer.NoMaterialBuilding:
//case MeshLayer.BuildingMaterialCutout:
//case MeshLayer.NoMaterialBuildingCutout:
//case MeshLayer.BuildingMaterialTransparent:
//case MeshLayer.NoMaterialBuildingTransparent:
// {
// if (tile.buildingType == default(BuildingStruct))
// {
// buffer.meshData = null;
// return;
// }
// if (!ContentLoader.Instance.BuildingMeshConfiguration.GetValue(tile, layer, out meshContent))
// {
// buffer.meshData = null;
// return;
// }
// }
// break;
default:
{
if (layer == MeshLayer.NaturalTerrain)
{
if (VoxelGenerator.IsNatural(tile) && !VoxelGenerator.HandleShape(tile) && !VoxelGenerator.UseBoth(tile))
{
layer = MeshLayer.StaticMaterial;
}
else
{
buffer.meshData = null;
return;
}
}
else if (VoxelGenerator.IsNatural(tile) && !VoxelGenerator.UseBoth(tile))
{
buffer.meshData = null;
return;
}
if (!ContentLoader.Instance.TileMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
}
break;
}
if (!meshContent.MeshData.ContainsKey(layer))
{
buffer.meshData = null;
return;
}
buffer.meshData = meshContent.MeshData[layer];
buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
Matrix4x4 matTexTransform = ContentLoader.Instance.DefaultMatTexTransform;
Matrix4x4 shapeTextTransform = ContentLoader.Instance.DefaultShapeTexTransform;
Matrix4x4 specialTexTransform = Matrix4x4.identity;
NormalContent tileTexContent;
if (meshContent.ShapeTexture == null)
{
//if (layer == MeshLayer.BuildingMaterial
// || layer == MeshLayer.BuildingMaterialCutout
// || layer == MeshLayer.NoMaterialBuilding
// || layer == MeshLayer.NoMaterialBuildingCutout
// || layer == MeshLayer.BuildingMaterialTransparent
// || layer == MeshLayer.NoMaterialBuildingTransparent
// )
//{
// if (ContentLoader.Instance.BuildingShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
// {
// shapeTextTransform = tileTexContent.UVTransform;
// index1.y = tileTexContent.ArrayIndex;
// }
//}
//else
{
if (ContentLoader.Instance.ShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
{
shapeTextTransform = tileTexContent.UVTransform;
index1.y = tileTexContent.ArrayIndex;
}
}
}
else
{
shapeTextTransform = meshContent.ShapeTexture.UVTransform;
index1.y = meshContent.ShapeTexture.ArrayIndex;
}
if (meshContent.MaterialTexture != null &&
(layer == MeshLayer.NoMaterial
//|| layer == MeshLayer.NoMaterialBuilding
//|| layer == MeshLayer.NoMaterialBuildingCutout
//|| layer == MeshLayer.NoMaterialBuildingTransparent
|| layer == MeshLayer.NoMaterialCutout ||
layer == MeshLayer.NoMaterialTransparent))
{
matTexTransform = meshContent.MaterialTexture.UVTransform;
index1.x = meshContent.MaterialTexture.ArrayIndex;
}
else
{
TextureContent matTexContent;
if (ContentLoader.Instance.MaterialTextureConfiguration.GetValue(tile, layer, out matTexContent))
{
matTexTransform = matTexContent.UVTransform;
index1.x = matTexContent.ArrayIndex;
}
}
if (meshContent.SpecialTexture != null)
{
specialTexTransform = meshContent.SpecialTexture.UVTransform;
index2.x = meshContent.SpecialTexture.ArrayIndex;
}
else
{
specialTexTransform = ContentLoader.Instance.DefaultSpecialTexTransform;
index2.x = ContentLoader.Instance.DefaultSpecialTexArrayIndex;
}
ColorContent newColorContent;
Color newColor;
if (ContentLoader.Instance.ColorConfiguration.GetValue(tile, layer, out newColorContent))
{
newColor = newColorContent.color;
}
else
{
MatPairStruct mat = new MatPairStruct(-1, -1);
switch (layer)
{
case MeshLayer.StaticMaterial:
case MeshLayer.StaticCutout:
case MeshLayer.StaticTransparent:
mat = tile.material;
break;
case MeshLayer.BaseMaterial:
case MeshLayer.BaseCutout:
case MeshLayer.BaseTransparent:
mat = tile.base_material;
break;
case MeshLayer.LayerMaterial:
case MeshLayer.LayerCutout:
case MeshLayer.LayerTransparent:
mat = tile.layer_material;
break;
case MeshLayer.VeinMaterial:
case MeshLayer.VeinCutout:
case MeshLayer.VeinTransparent:
mat = tile.vein_material;
break;
case MeshLayer.NoMaterial:
case MeshLayer.NoMaterialCutout:
//case MeshLayer.NoMaterialBuildingCutout:
//case MeshLayer.NoMaterialBuilding:
//case MeshLayer.NoMaterialBuildingTransparent:
case MeshLayer.NoMaterialTransparent:
break;
//case MeshLayer.BuildingMaterial:
//case MeshLayer.BuildingMaterialCutout:
//case MeshLayer.BuildingMaterialTransparent:
// mat = tile.buildingMaterial;
// break;
default:
break;
}
MaterialDefinition mattie;
if (materials.TryGetValue(mat, out mattie))
{
ColorDefinition color = mattie.state_color;
if (color == null)
{
newColor = Color.cyan;
}
else
{
newColor = new Color(color.red / 255.0f, color.green / 255.0f, color.blue / 255.0f, 1);
}
}
else
{
newColor = Color.grey;
}
}
buffer.color = newColor;
if (TextureStorage.UsingArray)
{
buffer.uv1Transform = Matrix4x4.identity;
buffer.uv2Force = index1;
buffer.uv3Force = index2;
}
else
{
buffer.uv1Transform = matTexTransform;
buffer.uv2Transform = shapeTextTransform;
buffer.uv3Transform = specialTexTransform;
}
buffer.hiddenFaces = CalculateHiddenFaces(tile, meshContent.Rotation);
}
/// <summary>
/// This is the function that actually decides what mesh and texture each tile gets
/// </summary>
/// <param name="buffer">Buffer to put the chosen meshes into for combining</param>
/// <param name="layer">layer currently being worked on</param>
/// <param name="tile">The tile to get all the needed info from.</param>
void FillMeshBuffer(out MeshCombineUtility.MeshInstance buffer, MeshLayer layer, MapDataStore.Tile tile, Vector3 pos)
{
buffer = new MeshCombineUtility.MeshInstance();
Vector2 index1 = Vector2.zero;
Vector2 index2 = Vector2.zero;
MeshContent meshContent = null;
buffer.color = Color.grey;
if (layer == MeshLayer.Collision)
{
if (!ContentLoader.Instance.CollisionMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
if (meshContent.MeshData.ContainsKey(MeshLayer.Collision))
{
buffer.meshData = meshContent.MeshData[MeshLayer.Collision];
}
else if (meshContent.MeshData.ContainsKey(MeshLayer.StaticMaterial))
{
buffer.meshData = meshContent.MeshData[MeshLayer.StaticMaterial];
}
else
{
buffer.meshData = null;
return;
}
buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
buffer.hiddenFaces = CalculateHiddenFaces(tile, meshContent.Rotation);
return;
}
if (ContentLoader.Instance.DesignationMeshConfiguration.GetValue(tile, layer, out meshContent))
{
if (!meshContent.MeshData.ContainsKey(layer))
{
buffer.meshData = null;
return;
}
buffer.meshData = meshContent.MeshData[layer];
buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
index1.x = ContentLoader.GetPatternIndex(tile.DesignationMat) / ContentLoader.Instance.PatternTextureDepth;
buffer.color = ContentLoader.GetColor(tile.DesignationMat);
if (meshContent.ShapeTexture != null)
{
index1.y = meshContent.ShapeTexture.ArrayIndex;
}
else
{
index1.y = ContentLoader.Instance.DefaultShapeTexArrayIndex;
}
if (meshContent.SpecialTexture != null)
{
index2.x = meshContent.SpecialTexture.ArrayIndex;
}
else
{
index2.x = ContentLoader.Instance.DefaultSpecialTexArrayIndex;
}
buffer.uv1Transform = Matrix4x4.identity;
buffer.uv2Force = index1;
buffer.uv3Force = index2;
buffer.hiddenFaces = CalculateHiddenFaces(tile, meshContent.Rotation);
return;
}
var matColor = ContentLoader.GetColor(tile.GetMaterial(layer));
var matPatternIndex = ContentLoader.GetPatternIndex(tile.GetMaterial(layer));
switch (layer)
{
case MeshLayer.GrowthMaterial:
case MeshLayer.GrowthCutout:
case MeshLayer.GrowthTransparent:
matColor = ContentLoader.GetColor(new MatPairStruct(55, 0), tile.GetMaterial(layer));
break;
case MeshLayer.GrowthMaterial1:
case MeshLayer.GrowthCutout1:
case MeshLayer.GrowthTransparent1:
matColor = ContentLoader.GetColor(new MatPairStruct(55, 1), tile.GetMaterial(layer));
break;
case MeshLayer.GrowthMaterial2:
case MeshLayer.GrowthCutout2:
case MeshLayer.GrowthTransparent2:
matColor = ContentLoader.GetColor(new MatPairStruct(55, 2), tile.GetMaterial(layer));
break;
case MeshLayer.GrowthMaterial3:
case MeshLayer.GrowthCutout3:
case MeshLayer.GrowthTransparent3:
matColor = ContentLoader.GetColor(new MatPairStruct(55, 3), tile.GetMaterial(layer));
break;
default:
break;
}
switch (layer)
{
case MeshLayer.GrowthMaterial:
case MeshLayer.GrowthMaterial1:
case MeshLayer.GrowthMaterial2:
case MeshLayer.GrowthMaterial3:
case MeshLayer.GrowthCutout:
case MeshLayer.GrowthCutout1:
case MeshLayer.GrowthCutout2:
case MeshLayer.GrowthCutout3:
case MeshLayer.GrowthTransparent:
case MeshLayer.GrowthTransparent1:
case MeshLayer.GrowthTransparent2:
case MeshLayer.GrowthTransparent3:
{
switch (tile.tiletypeMaterial)
{
case TiletypeMaterial.PLANT:
case TiletypeMaterial.ROOT:
case TiletypeMaterial.TREE_MATERIAL:
case TiletypeMaterial.MUSHROOM:
if (!ContentLoader.Instance.GrowthMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
break;
default:
buffer.meshData = null;
return;
}
}
break;
default:
{
if (layer == MeshLayer.NaturalTerrain)
{
if (VoxelGenerator.IsNatural(tile) && !VoxelGenerator.HandleShape(tile) && !VoxelGenerator.UseBoth(tile))
{
layer = MeshLayer.StaticMaterial;
}
else
{
buffer.meshData = null;
return;
}
}
else if (VoxelGenerator.IsNatural(tile) && !VoxelGenerator.UseBoth(tile))
{
buffer.meshData = null;
return;
}
if (!ContentLoader.Instance.TileMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
}
break;
}
//Use the transparent shader instead of the opaque shader if the material is transparent.
if (matColor.a < 0.5f)
{
switch (layer)
{
case MeshLayer.StaticMaterial:
case MeshLayer.BaseMaterial:
case MeshLayer.LayerMaterial:
case MeshLayer.VeinMaterial:
buffer.meshData = null;
return;
case MeshLayer.StaticTransparent:
layer = MeshLayer.StaticMaterial;
break;
case MeshLayer.BaseTransparent:
layer = MeshLayer.BaseMaterial;
break;
case MeshLayer.LayerTransparent:
layer = MeshLayer.LayerMaterial;
break;
case MeshLayer.VeinTransparent:
layer = MeshLayer.VeinMaterial;
break;
default:
break;
}
}
if (!meshContent.MeshData.ContainsKey(layer))
{
buffer.meshData = null;
return;
}
buffer.meshData = meshContent.MeshData[layer];
buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
Matrix4x4 shapeTextTransform = ContentLoader.Instance.DefaultShapeTexTransform;
Matrix4x4 specialTexTransform = Matrix4x4.identity;
NormalContent tileTexContent;
if (meshContent.ShapeTexture == null)
{
if (ContentLoader.Instance.ShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
{
shapeTextTransform = tileTexContent.UVTransform;
index1.y = tileTexContent.ArrayIndex;
}
}
else
{
shapeTextTransform = meshContent.ShapeTexture.UVTransform;
index1.y = meshContent.ShapeTexture.ArrayIndex;
}
index1.x = matPatternIndex / ContentLoader.Instance.PatternTextureDepth;
if (meshContent.SpecialTexture != null)
{
specialTexTransform = meshContent.SpecialTexture.UVTransform;
index2.x = meshContent.SpecialTexture.ArrayIndex;
}
else
{
specialTexTransform = ContentLoader.Instance.DefaultSpecialTexTransform;
index2.x = ContentLoader.Instance.DefaultSpecialTexArrayIndex;
}
buffer.color = matColor;
buffer.uv1Transform = Matrix4x4.identity;
buffer.uv2Force = index1;
buffer.uv3Force = index2;
buffer.hiddenFaces = CalculateHiddenFaces(tile, meshContent.Rotation);
}
public static void ShowWindow()
{
VoxelGenerator window = (VoxelGenerator)EditorWindow.GetWindow(typeof(VoxelGenerator));
}
public ChunkData(VoxelSettings voxelSettings, MeshSettings meshSettings)
{
voxelGen = VoxelGeneratorFactory.CreateInstance(voxelSettings);
meshGen = MeshGeneratorFactory.CreateInstance(meshSettings);
meshGen.VoxelGenerator = voxelGen;
}
