public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
Content cont;
switch (layer)
{
case MeshLayer.BuildingMaterial:
case MeshLayer.NoMaterialBuilding:
case MeshLayer.BuildingMaterialCutout:
case MeshLayer.NoMaterialBuildingCutout:
if (defaultTile != null)
{
value = defaultTile.GetValue(tile, layer);
return(true);
}
break;
default:
if (tiletypeMatcher.Get(tile.tileType, out cont))
{
value = cont.GetValue(tile, layer);
return(true);
}
break;
}
value = invalidContent.GetValue(tile, layer);
return(false);
}
bool GetMaterialRef(MatPairStruct material, MapDataStore.Tile tile, MeshLayer layer, out T value)
{
Content cont;
if (materialMatcher.TryGetValue(material, out cont))
{
if (thisMaterialMatcher == null)
{
value = cont.GetValue(tile, layer);
return(true);
}
else if (cont.overloadedItem != null)
{
if (cont.overloadedItem.GetValue(tile, layer, out value))
{
return(true);
}
}
}
if (thisMaterialMatcher != null && thisMaterialMatcher.TryGetValue(material, out value))
{
return(true);
}
value = default(T);
return(false);
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
Content cont;
//if (layer == MeshLayer.BuildingMaterial
// || layer == MeshLayer.BuildingMaterialCutout
// || layer == MeshLayer.NoMaterialBuilding
// || layer == MeshLayer.NoMaterialBuildingCutout
// )
//{
// //Buildings are always built from the same item type, generally.
// if (itemMatcher.Get(new MatPairStruct(-1, -1), out cont))
// {
// value = cont.GetValue(tile, layer);
// return true;
// }
//}
//else
if (itemMatcher.Get(tile.construction_item, out cont))
{
value = cont.GetValue(tile, layer);
return(true);
}
value = default(T);
return(false);
}
private void RemoveActorLayer(VisualizationDataSource dataSource)
{
MeshLayer meshLayer = meshLayers.Find(ml => ml.Guid == dataSource.Guid);
if (meshLayer != null)
{
meshLayers.Remove(meshLayer);
}
}
public void MeshDataTest(MeshLayer input)
{
var serializer = new MeshLayerHandler();
var output = (MeshLayer)serializer.Reserialize(input);
Assert.That(output.Id, Is.EqualTo(input.Id));
Assert.That(output.Ref, Is.EqualTo(input.Ref));
Assert.That(output.MaterialId, Is.EqualTo(input.MaterialId));
Assert.That(output.Indexes, Is.EquivalentTo(input.Indexes));
Assert.That(output.RData, Is.EquivalentTo(input.RData));
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
Content cont;
if (buildingMatcher.Get(tile.buildingType, out cont))
{
value = cont.GetValue(tile, layer);
return(true);
}
value = default(T);
return(false);
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
Content cont;
if (tiletypeMatcher.Get(tile.tileType, out cont))
{
value = cont.GetValue(tile, layer);
return(true);
}
value = invalidContent.GetValue(tile, layer);
return(false);
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
Content cont;
if (itemMatcher.Get(tile.construction_item, out cont))
{
value = cont.GetValue(tile, layer);
return(true);
}
value = default(T);
return(false);
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
if (tile.Up == null)
{
if (open != null)
{
value = open.GetValue(tile, layer);
return(true);
}
else
{
value = default(T);
return(false);
}
}
switch (tile.Up.shape)
{
case RemoteFortressReader.TiletypeShape.NO_SHAPE:
case RemoteFortressReader.TiletypeShape.EMPTY:
case RemoteFortressReader.TiletypeShape.RAMP_TOP:
case RemoteFortressReader.TiletypeShape.BROOK_TOP:
case RemoteFortressReader.TiletypeShape.ENDLESS_PIT:
case RemoteFortressReader.TiletypeShape.BRANCH:
case RemoteFortressReader.TiletypeShape.TRUNK_BRANCH:
case RemoteFortressReader.TiletypeShape.TWIG:
if (open != null)
{
value = open.GetValue(tile, layer);
return(true);
}
else
{
value = default(T);
return(false);
}
default:
if (covered != null)
{
value = covered.GetValue(tile, layer);
return(true);
}
else
{
value = default(T);
return(false);
}
}
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
if (coordList.ContainsKey(tile.buildingLocalPos))
{
value = coordList[tile.buildingLocalPos].GetValue(tile, layer);
return(true);
}
DFCoord2d any = new DFCoord2d(-1, -1);
if (coordList.ContainsKey(any))
{
value = coordList[any].GetValue(tile, layer);
return(true);
}
value = default(T);
return(false);
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
if (tile.shape != RemoteFortressReader.TiletypeShape.RAMP)
{
value = default(T);
return(false);
}
int index = tile.RampType - 1;
if (rampList[index] == null)
{
value = default(T);
return(false);
}
value = rampList[index].GetValue(tile, layer);
return(true);
}
public T GetValue(MapDataStore.Tile tile, MeshLayer layer)
{
if (overloadedItem == null)
{
return(defaultItem);
}
else
{
T item;
if (overloadedItem.GetValue(tile, layer, out item))
{
return(item);
}
else
{
return(defaultItem);
}
}
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
double maxValue = float.MinValue;
Content maxContent = null;
foreach (var item in items)
{
double curValue = (
item.noise.eval(tile.position.x / item.scale_x, tile.position.y / item.scale_y, tile.position.z / item.scale_z)
+ 0.944824004155211) * item.intensity; // -0.944824004155211 was found on testing to be the minimum.
if (curValue > maxValue)
{
maxValue = curValue;
maxContent = item.content;
}
}
if (maxContent == null)
{
value = default(T);
return(false);
}
value = maxContent.GetValue(tile, layer);
return(true);
}
public SceneImportResult LoadStaticMesh(string filename)
{
var file = new FileInfo(filename);
VertexDescriptor vd = VertexDescriptor.Get <ModelVertex>();
List <MeshLayer> layers = new List <MeshLayer>();
int[] adjacency;
ExtendedMaterial[] meshMaterials;
Mesh mesh = new Mesh(vd);
List <MeshMaterial> material = new List <MeshMaterial>();
using (SlimDX.Direct3D9.Mesh d3dMesh = SlimDX.Direct3D9.Mesh.FromFile(Engine.Graphics, filename, MeshFlags.Managed))
{
adjacency = d3dMesh.GetAdjacency();
meshMaterials = d3dMesh.GetMaterials();
for (int i = 0; i < meshMaterials.Length; i++)
{
var matd3d = meshMaterials[i].MaterialD3D;
string textureFilename = meshMaterials[i].TextureFileName;
if (textureFilename != null && !Path.IsPathRooted(textureFilename))
{
textureFilename = Path.Combine(Path.GetDirectoryName(filename), textureFilename);
}
material.Add(new MeshMaterial()
{
Name = file.Name + "_material" + i,
Alpha = matd3d.Diffuse.Alpha,
Diffuse = matd3d.Diffuse.ToVector3(),
Specular = matd3d.Specular.ToVector3(),
SpecularPower = Math.Max(1, matd3d.Power),
Reflectivity = 0,
Refractitity = 0,
EmissiveColor = matd3d.Emissive.ToVector3(),
DiffuseMap = textureFilename != null && File.Exists(textureFilename) ?
textureFilename : null
});
}
ModelVertex[] vertexes = new ModelVertex[d3dMesh.VertexCount];
Array indices;
if (d3dMesh.IndexBuffer.Description.Format == Format.Index16)
{
indices = new ushort[d3dMesh.FaceCount * 3];
}
else
{
indices = new uint[d3dMesh.FaceCount * 3];
}
DataStream vertexStream = d3dMesh.LockVertexBuffer(0);
VertexDescriptor meshVD = new VertexDescriptor(d3dMesh.GetDeclaration());
int positionOffset = meshVD.GetOffset(DeclarationUsage.Position, 0);
int normalOffset = meshVD.GetOffset(DeclarationUsage.Normal, 0);
int texCoordOffset = meshVD.GetOffset(DeclarationUsage.TextureCoordinate, 0);
byte[] buffer;
unsafe
{
buffer = new byte[vertexStream.Length];
vertexStream.Read(buffer, 0, (int)vertexStream.Length);
fixed(byte *_pter = buffer)
{
byte *pter = _pter;
for (int i = 0; i < d3dMesh.VertexCount; i++)
{
vertexes[i].Position = *((Vector3 *)(pter + positionOffset));
if (normalOffset > 0)
{
vertexes[i].Normal = *((Vector3 *)(pter + normalOffset));
}
if (texCoordOffset > 0)
{
vertexes[i].TexCoord = *((Vector2 *)(pter + texCoordOffset));
}
pter += d3dMesh.BytesPerVertex;
}
}
d3dMesh.UnlockVertexBuffer();
DataStream indexStream = d3dMesh.LockIndexBuffer(0);
GCHandle handler = GCHandle.Alloc(indices, GCHandleType.Pinned);
byte * indexPter = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(indices, 0);
buffer = new byte[indexStream.Length];
indexStream.Read(buffer, 0, (int)indexStream.Length);
for (int i = 0; i < indexStream.Length; i++)
{
indexPter[i] = buffer[i];
}
handler.Free();
d3dMesh.UnlockIndexBuffer();
}
mesh.CreateVertexBuffer(vertexes);
if (d3dMesh.IndexBuffer.Description.Format == Format.Index16)
{
mesh.CreateIndexBuffer((ushort[])indices);
}
else
{
mesh.CreateIndexBuffer((uint[])indices);
}
var d3dComponents = d3dMesh.GetAttributeTable();
if (d3dComponents == null)
{
MeshLayer component = new MeshLayer();
layers.Add(component);
material.Add(MeshMaterial.CreateDefaultMaterial(file.Name + "_default"));
component.materialIndex = 0;
component.primitiveCount = mesh.FaceCount;
component.startIndex = 0;
component.startVertex = 0;
component.vertexCount = mesh.VertexCount;
}
else
{
for (int i = 0; i < d3dComponents.Length; i++)
{
AttributeRange ar = d3dComponents[i];
MeshLayer component = new MeshLayer();
layers.Add(component);
component.materialIndex = ar.AttribId;
component.primitiveCount = ar.FaceCount;
component.startIndex = ar.FaceStart * 3;
component.startVertex = ar.VertexStart;
component.vertexCount = ar.VertexCount;
}
}
mesh.Materials = material.ToArray();
mesh.SetLayers(layers.ToArray());
if (normalOffset < 0)
{
mesh.ComputeNormals();
}
if (texCoordOffset < 0)
{
mesh.ComputeTextureCoords(CoordMappingType.Spherical);
}
mesh.ComputeTangents();
meshVD.Dispose();
}
StaticMeshSceneNode meshNode = new StaticMeshSceneNode(file.Name, mesh);
return(new SceneImportResult {
VisualSceneRoot = meshNode, VisualMaterials = material
});
}
/// <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();
MeshContent meshContent = null;
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 (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 (!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 shapeTextTransform = ContentLoader.Instance.DefaultShapeTexTransform;
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;
}
}
else
{
if (ContentLoader.Instance.ShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
{
shapeTextTransform = tileTexContent.UVTransform;
}
}
}
else
{
shapeTextTransform = meshContent.ShapeTexture.UVTransform;
}
Matrix4x4 matTexTransform = ContentLoader.Instance.DefaultMatTexTransform;
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;
}
else
{
TextureContent matTexContent;
if (ContentLoader.Instance.MaterialTextureConfiguration.GetValue(tile, layer, out matTexContent))
{
matTexTransform = matTexContent.UVTransform;
}
}
Matrix4x4 specialTexTransform = Matrix4x4.identity;
if (meshContent.SpecialTexture != null)
{
specialTexTransform = meshContent.SpecialTexture.UVTransform;
}
else
{
specialTexTransform = ContentLoader.Instance.DefaultSpecialTexTransform;
}
ColorContent newColorContent;
Color newColor;
if (ContentLoader.Instance.ColorConfiguration.GetValue(tile, layer, out newColorContent))
{
newColor = newColorContent.value;
}
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;
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();
MeshContent meshContent = null;
if(contentLoader.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 (meshContent.MaterialTexture != null)
buffer.uv1Transform = meshContent.MaterialTexture.UVTransform;
else
buffer.uv1Transform = contentLoader.DefaultMatTexTransform;
if (meshContent.ShapeTexture != null)
buffer.uv2Transform = meshContent.ShapeTexture.UVTransform;
else
buffer.uv2Transform = contentLoader.DefaultShapeTexTransform;
if (meshContent.SpecialTexture != null)
buffer.uv3Transform = meshContent.SpecialTexture.UVTransform;
else
buffer.uv3Transform = contentLoader.DefaultSpecialTexTransform;
buffer.hiddenFaces = CalculateHiddenFaces(tile);
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.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.BuildingMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
}
break;
default:
{
if (!contentLoader.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 shapeTextTransform = contentLoader.DefaultShapeTexTransform;
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.BuildingShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
shapeTextTransform = tileTexContent.UVTransform;
}
else
{
if (contentLoader.ShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
shapeTextTransform = tileTexContent.UVTransform;
}
}
else
{
shapeTextTransform = meshContent.ShapeTexture.UVTransform;
}
Matrix4x4 matTexTransform = contentLoader.DefaultMatTexTransform;
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;
}
else
{
TextureContent matTexContent;
if (contentLoader.MaterialTextureConfiguration.GetValue(tile, layer, out matTexContent))
matTexTransform = matTexContent.UVTransform;
}
Matrix4x4 specialTexTransform = Matrix4x4.identity;
if(meshContent.SpecialTexture != null)
{
specialTexTransform = meshContent.SpecialTexture.UVTransform;
}
else
{
specialTexTransform = contentLoader.DefaultSpecialTexTransform;
}
ColorContent newColorContent;
Color newColor;
if (contentLoader.ColorConfiguration.GetValue(tile, layer, out newColorContent))
{
newColor = newColorContent.value;
}
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;
buffer.uv1Transform = matTexTransform;
buffer.uv2Transform = shapeTextTransform;
buffer.uv3Transform = specialTexTransform;
buffer.hiddenFaces = CalculateHiddenFaces(tile);
}
//Dictionary<string, Texture2D> diffuseTextures = new Dictionary<string, Texture2D>();
//Dictionary<string, Texture2D> specularTextures = new Dictionary<string, Texture2D>();
//Dictionary<string, geometry> geometryLibrary = new Dictionary<string, geometry>();
//List<node> nodeList = new List<node>();
//this is very similar to the blockmesher function.
void CollectModel(MapDataStore.Tile tile, MeshLayer layer, DFCoord pos)
{
if (layer == MeshLayer.Collision)
{
return;
}
#region Mesh Selection
MeshContent meshContent = null;
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))
{
return;
}
break;
default:
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))
// return;
// if (!ContentLoader.Instance.BuildingMeshConfiguration.GetValue(tile, layer, out meshContent))
// return;
// }
// break;
default:
{
if (!ContentLoader.Instance.TileMeshConfiguration.GetValue(tile, layer, out meshContent))
{
return;
}
}
break;
}
if (!meshContent.MeshData.ContainsKey(layer))
{
return;
}
#endregion
node tileNode = new node();
tileNode.id = string.Format("Tile[{0},{1},{2}]_{3}", pos.x, pos.y, pos.z, layer);
tileNode.Items = new object[]
{
COLLADA.ConvertMatrix(Matrix4x4.TRS(
GameMap.DFtoUnityCoord(pos),
meshContent.GetRotation(tile),
Vector3.one))
};
tileNode.ItemsElementName = new ItemsChoiceType2[] { ItemsChoiceType2.matrix };
//string geometryName = "Mesh-" + meshContent.UniqueIndex;
//if (!geometryLibrary.ContainsKey(geometryName))
//{
// geometryLibrary[geometryName] = COLLADA.MeshToGeometry(meshContent.MeshData[layer], geometryName);
//}
//instance_geometry geometryInstance = new instance_geometry();
//geometryInstance.url = "#" + geometryLibrary[geometryName].id;
//tileNode.instance_geometry = new instance_geometry[] { geometryInstance };
//nodeList.Add(tileNode);
//return;
//-----------------------------------------------------------
//Put normal map stuff here! Remember!
//-----------------------------------------------------------
//string patternName = "Tex-";
//Texture2D tiletexture = null;
//TextureContent textureContent;
//if (ContentLoader.Instance.MaterialTextureConfiguration.GetValue(tile, layer, out textureContent))
//{
// tiletexture = textureContent.Texture;
// patternName += textureContent.UniqueIndex;
//}
//else patternName += "#";
//patternName += "-#";
//Color color = Color.grey;
//ColorContent colorContent;
//if (ContentLoader.Instance.ColorConfiguration.GetValue(tile, layer, out colorContent))
//{
// color = colorContent.color;
//}
//patternName += string.Format("{0:X2}{1:X2}{2:X2}", ((Color32)color).r, ((Color32)color).g, ((Color32)color).b);
//if (diffuseTextures.ContainsKey(patternName))
// return;
//Color neutralSpec = new Color(0.04f, 0.04f, 0.04f);
//Texture2D outputDiffuse;
//Texture2D outputSpec;
//if (tiletexture != null)
//{
// outputDiffuse = new Texture2D(tiletexture.width, tiletexture.height);
// outputSpec = new Texture2D(tiletexture.width, tiletexture.height);
// Color[] colors = tiletexture.GetPixels();
// Color[] specs = new Color[colors.Length];
// for (int i = 0; i < colors.Length; i++)
// {
// var diffuseColor = OverlayBlend(colors[i], color);
// diffuseColor.a = 1;
// colors[i] = Color.Lerp(Color.black, diffuseColor, color.a);
// specs[i] = Color.Lerp(diffuseColor, neutralSpec, color.a);
// }
// outputDiffuse.SetPixels(colors);
// outputSpec.SetPixels(specs);
//}
//else
//{
// outputDiffuse = ContentLoader.CreateFlatTexture(color);
// outputSpec = ContentLoader.CreateFlatTexture(neutralSpec);
//}
//outputDiffuse.name = patternName + "_Diffuse";
//outputSpec.name = patternName + "_Specular";
//diffuseTextures[patternName] = outputDiffuse;
//specularTextures[patternName] = outputSpec;
}
abstract public bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value);
/// <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)
{
buffer = new MeshCombineUtility.MeshInstance();
MeshContent mesh = null;
if (tile.hidden)
{
buffer.meshData = null;
return;
}
if (layer == MeshLayer.BuildingMaterial
|| layer == MeshLayer.BuildingMaterialCutout
|| layer == MeshLayer.NoMaterialBuilding
|| layer == MeshLayer.NoMaterialBuildingCutout
|| layer == MeshLayer.BuildingMaterialTransparent
|| layer == MeshLayer.NoMaterialBuildingTransparent
)
{
if(tile.buildingType == default(BuildingStruct))
{
buffer.meshData = null;
return;
}
if (!contentLoader.BuildingMeshConfiguration.GetValue(tile, layer, out mesh))
{
buffer.meshData = null;
return;
}
}
else
{
if (!contentLoader.TileMeshConfiguration.GetValue(tile, layer, out mesh))
{
buffer.meshData = null;
return;
}
}
buffer.meshData = mesh.MeshData[(int)layer];
buffer.transform = Matrix4x4.TRS(GameMap.DFtoUnityCoord(tile.position), mesh.GetRotation(tile), Vector3.one);
Matrix4x4 shapeTextTransform = Matrix4x4.identity;
NormalContent tileTexContent;
if (mesh.NormalTexture == null)
{
if (layer == MeshLayer.BuildingMaterial
|| layer == MeshLayer.BuildingMaterialCutout
|| layer == MeshLayer.NoMaterialBuilding
|| layer == MeshLayer.NoMaterialBuildingCutout
|| layer == MeshLayer.BuildingMaterialTransparent
|| layer == MeshLayer.NoMaterialBuildingTransparent
)
{
if (contentLoader.BuildingShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
shapeTextTransform = tileTexContent.UVTransform;
}
else
{
if (contentLoader.ShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
shapeTextTransform = tileTexContent.UVTransform;
}
}
else
{
shapeTextTransform = mesh.NormalTexture.UVTransform;
}
Matrix4x4 matTexTransform = Matrix4x4.identity;
TextureContent matTexContent;
if (contentLoader.MaterialTextureConfiguration.GetValue(tile, layer, out matTexContent))
matTexTransform = matTexContent.UVTransform;
ColorContent newColorContent;
Color newColor;
if (contentLoader.ColorConfiguration.GetValue(tile, layer, out newColorContent))
{
newColor = newColorContent.value;
}
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.Growth0Cutout:
break;
case MeshLayer.Growth1Cutout:
break;
case MeshLayer.Growth2Cutout:
break;
case MeshLayer.Growth3Cutout:
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;
buffer.uv1Transform = matTexTransform;
buffer.uv2Transform = shapeTextTransform;
buffer.hiddenFaces = MeshCombineUtility.HiddenFaces.None;
if (tile.North != null && tile.North.isWall)
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.North;
if (tile.South != null && tile.South.isWall)
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.South;
if (tile.East != null && tile.East.isWall)
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.East;
if (tile.West != null && tile.West.isWall)
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.West;
if (tile.Up != null && tile.Up.isSolidBase)
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.Up;
if (tile.Down != null && tile.Down.isWall)
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.Down;
}
void FillMeshBuffer(out MeshCombineUtility.MeshInstance buffer, MeshLayer layer, MapDataStore.Tile tile)
{
buffer = new MeshCombineUtility.MeshInstance();
MeshContent content = null;
if (!contentLoader.TileMeshConfiguration.GetValue(tile, layer, out content))
{
buffer.meshData = null;
return;
}
buffer.meshData = content.meshData[(int)layer];
buffer.transform = Matrix4x4.TRS(GameMap.DFtoUnityCoord(tile.position), Quaternion.identity, Vector3.one);
Matrix4x4 shapeTextTransform = Matrix4x4.identity;
NormalContent tileTexContent;
if (contentLoader.ShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
{
shapeTextTransform = tileTexContent.UVTransform;
}
Matrix4x4 matTexTransform = Matrix4x4.identity;
TextureContent matTexContent;
if (contentLoader.MaterialTextureConfiguration.GetValue(tile, layer, out matTexContent))
{
matTexTransform = matTexContent.UVTransform;
}
ColorContent newColorContent;
Color newColor;
if (contentLoader.ColorConfiguration.GetValue(tile, layer, out newColorContent))
{
newColor = newColorContent.value;
}
else
{
MatPairStruct mat;
mat.mat_type = -1;
mat.mat_index = -1;
switch (layer)
{
case MeshLayer.StaticMaterial:
case MeshLayer.StaticCutout:
mat = tile.material;
break;
case MeshLayer.BaseMaterial:
case MeshLayer.BaseCutout:
mat = tile.base_material;
break;
case MeshLayer.LayerMaterial:
case MeshLayer.LayerCutout:
mat = tile.layer_material;
break;
case MeshLayer.VeinMaterial:
case MeshLayer.VeinCutout:
mat = tile.vein_material;
break;
case MeshLayer.NoMaterial:
case MeshLayer.NoMaterialCutout:
break;
case MeshLayer.Growth0Cutout:
break;
case MeshLayer.Growth1Cutout:
break;
case MeshLayer.Growth2Cutout:
break;
case MeshLayer.Growth3Cutout:
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;
buffer.uv1Transform = matTexTransform;
buffer.uv2Transform = shapeTextTransform;
buffer.hiddenFaces = MeshCombineUtility.HiddenFaces.None;
if (tile.North != null && tile.North.Value.isWall)
{
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.North;
}
if (tile.South != null && tile.South.Value.isWall)
{
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.South;
}
if (tile.East != null && tile.East.Value.isWall)
{
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.East;
}
if (tile.West != null && tile.West.Value.isWall)
{
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.West;
}
if (tile.Up != null && tile.Up.Value.isSolidBase)
{
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.Up;
}
if (tile.Down != null && tile.Down.Value.isWall)
{
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.Down;
}
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
MatPairStruct mat = tile.material;
int plantIndex = mat.mat_index;
switch (layer)
{
case MeshLayer.StaticMaterial:
case MeshLayer.StaticCutout:
case MeshLayer.StaticTransparent:
return(GetMaterialRef(tile.material, tile, layer, out value));
case MeshLayer.BaseMaterial:
case MeshLayer.BaseCutout:
case MeshLayer.BaseTransparent:
return(GetMaterialRef(tile.base_material, tile, layer, out value));
case MeshLayer.LayerMaterial:
case MeshLayer.LayerCutout:
case MeshLayer.LayerTransparent:
return(GetMaterialRef(tile.layer_material, tile, layer, out value));
case MeshLayer.VeinMaterial:
case MeshLayer.VeinCutout:
case MeshLayer.VeinTransparent:
return(GetMaterialRef(tile.vein_material, tile, layer, out value));
case MeshLayer.NoMaterial:
case MeshLayer.NoMaterialCutout:
case MeshLayer.NoMaterialBuildingCutout:
case MeshLayer.NoMaterialBuilding:
case MeshLayer.NoMaterialBuildingTransparent:
case MeshLayer.NoMaterialTransparent:
if (defaultMaterial == null)
{
break;
}
value = defaultMaterial.GetValue(tile, layer);
return(true);
case MeshLayer.BuildingMaterial:
case MeshLayer.BuildingMaterialCutout:
case MeshLayer.BuildingMaterialTransparent:
return(GetMaterialRef(tile.buildingMaterial, tile, layer, out value));
case MeshLayer.GrowthMaterial:
case MeshLayer.GrowthCutout:
case MeshLayer.GrowthTransparent:
if ((mat.mat_type != PlantType) ||
DFConnection.Instance.NetPlantRawList == null ||
DFConnection.Instance.NetPlantRawList.plant_raws.Count <= plantIndex ||
DFConnection.Instance.NetPlantRawList.plant_raws[plantIndex].growths.Count <= 0 ||
DFConnection.Instance.NetPlantRawList.plant_raws[plantIndex].growths[0].mat == null)
{
value = default(T);
return(false);
}
return(GetMaterialRef(DFConnection.Instance.NetPlantRawList.plant_raws[plantIndex].growths[0].mat, tile, layer, out value));
case MeshLayer.GrowthMaterial1:
case MeshLayer.GrowthCutout1:
case MeshLayer.GrowthTransparent1:
if ((mat.mat_type != PlantType) ||
DFConnection.Instance.NetPlantRawList == null ||
DFConnection.Instance.NetPlantRawList.plant_raws.Count <= plantIndex ||
DFConnection.Instance.NetPlantRawList.plant_raws[plantIndex].growths.Count <= 1 ||
DFConnection.Instance.NetPlantRawList.plant_raws[plantIndex].growths[0].mat == null)
{
value = default(T);
return(false);
}
return(GetMaterialRef(DFConnection.Instance.NetPlantRawList.plant_raws[plantIndex].growths[1].mat, tile, layer, out value));
case MeshLayer.GrowthMaterial2:
case MeshLayer.GrowthCutout2:
case MeshLayer.GrowthTransparent2:
if ((mat.mat_type != PlantType) ||
DFConnection.Instance.NetPlantRawList == null ||
DFConnection.Instance.NetPlantRawList.plant_raws.Count <= plantIndex ||
DFConnection.Instance.NetPlantRawList.plant_raws[plantIndex].growths.Count <= 2 ||
DFConnection.Instance.NetPlantRawList.plant_raws[plantIndex].growths[0].mat == null)
{
value = default(T);
return(false);
}
return(GetMaterialRef(DFConnection.Instance.NetPlantRawList.plant_raws[plantIndex].growths[2].mat, tile, layer, out value));
case MeshLayer.GrowthMaterial3:
case MeshLayer.GrowthCutout3:
case MeshLayer.GrowthTransparent3:
if ((mat.mat_type != PlantType) ||
DFConnection.Instance.NetPlantRawList == null ||
DFConnection.Instance.NetPlantRawList.plant_raws.Count <= plantIndex ||
DFConnection.Instance.NetPlantRawList.plant_raws[plantIndex].growths.Count <= 3 ||
DFConnection.Instance.NetPlantRawList.plant_raws[plantIndex].growths[0].mat == null)
{
value = default(T);
return(false);
}
return(GetMaterialRef(DFConnection.Instance.NetPlantRawList.plant_raws[plantIndex].growths[3].mat, tile, layer, out value));
default:
break;
}
value = default(T);
return(false);
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
value = content.GetValue(tile, layer);
return(true);
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
switch (tile.digDesignation)
{
case RemoteFortressReader.TileDigDesignation.NO_DIG:
break;
case RemoteFortressReader.TileDigDesignation.DEFAULT_DIG:
if (designationBlocks.ContainsKey(DesignationTypes.Default))
{
value = designationBlocks[DesignationTypes.Default].GetValue(tile, layer);
return(true);
}
break;
case RemoteFortressReader.TileDigDesignation.UP_DOWN_STAIR_DIG:
if (designationBlocks.ContainsKey(DesignationTypes.UpDownStairs))
{
value = designationBlocks[DesignationTypes.UpDownStairs].GetValue(tile, layer);
return(true);
}
break;
case RemoteFortressReader.TileDigDesignation.CHANNEL_DIG:
if (designationBlocks.ContainsKey(DesignationTypes.Channel))
{
value = designationBlocks[DesignationTypes.Channel].GetValue(tile, layer);
return(true);
}
break;
case RemoteFortressReader.TileDigDesignation.RAMP_DIG:
if (designationBlocks.ContainsKey(DesignationTypes.Ramp))
{
value = designationBlocks[DesignationTypes.Ramp].GetValue(tile, layer);
return(true);
}
break;
case RemoteFortressReader.TileDigDesignation.DOWN_STAIR_DIG:
if (designationBlocks.ContainsKey(DesignationTypes.DownStairs))
{
value = designationBlocks[DesignationTypes.DownStairs].GetValue(tile, layer);
return(true);
}
break;
case RemoteFortressReader.TileDigDesignation.UP_STAIR_DIG:
if (designationBlocks.ContainsKey(DesignationTypes.UpStairs))
{
value = designationBlocks[DesignationTypes.UpStairs].GetValue(tile, layer);
return(true);
}
break;
default:
break;
}
if (tile.Hidden)
{
if (designationBlocks.ContainsKey(DesignationTypes.Hidden))
{
value = designationBlocks[DesignationTypes.Hidden].GetValue(tile, layer);
return(true);
}
}
value = default(T);
return(false);
}
public EngineContent ToSceneNode()
{
string name = Path.GetFileNameWithoutExtension(this.name);
VertexDescriptor vd = EngineResources.CreateVertexDescriptor <ModelVertex>();
List <Tuple <string, Mesh> > meshes = new List <Tuple <string, Mesh> >(groups.Count);
List <SceneNode> nodes = new List <SceneNode>(groups.Count);
MeshMaterial[] sceneMaterials = new MeshMaterial[materials.Count];
Dictionary <string, MeshMaterial> materialLookup = new Dictionary <string, MeshMaterial>();
for (int i = 0; i < materials.Values.Count; i++)
{
var sourceMat = materials.Values[i];
sceneMaterials[i] = new MeshMaterial
{
Name = name + "_" + sourceMat.Name,
Surface = sourceMat.ToSurfaceInfo(),
NormalMap = sourceMat.NormalMap,
DiffuseMap = sourceMat.Textures != null && sourceMat.Textures.Length > 0 ?
sourceMat.Textures[0] : null
};
materialLookup.Add(sceneMaterials[i].Name, sceneMaterials[i]);
}
List <MeshLayer> layers = new List <MeshLayer>();
//register for each positionIndex in the source container the List of the destination vertices that contain that position
Dictionary <int, List <VertexInfo> > lookup = new Dictionary <int, List <VertexInfo> >();
VertexInfo vi;
ModelVertex v;
List <ModelVertex> vertexes = new List <ModelVertex>();
uint[] indexes;
#region Groups
foreach (var g in groups)
{
List <MeshMaterial> meshMaterials = new List <MeshMaterial>();
Mesh mesh = new Mesh(vd: vd);
mesh.Name = g.Name;
indexes = new uint[g.FaceCount * 3];
int k = 0;
#region Layers
layers.Clear();
foreach (var layer in g.Layers)
{
int startVertex = int.MaxValue;
int vertexCount = 0;
MeshLayer meshLayer = new MeshLayer();
meshLayer.startIndex = k;
meshLayer.primitiveCount = layer.Faces.Count;
var mat = materialLookup[name + "_" + layer.MaterialName];
meshLayer.materialIndex = meshMaterials.IndexOf(mat);
if (meshLayer.materialIndex < 0)
{
meshLayer.materialIndex = meshMaterials.Count;
meshMaterials.Add(mat);
}
#region Faces
foreach (var face in layer.Faces)
{
//for each vertex of the face create a new mesh vertex if the vertex if not yet in the mesh add it to the VertexBuffer
//and create a new face in the IndexBuffer
for (int i = 0; i < 3; i++)
{
//vi describe a new vertex
vi = new VertexInfo()
{
PositionIndex = face.Vertexes[i].Position, NormalIndex = -1, TcIndex = -1
};
//if the vertex position is not in the VertexBuffer add it
if (!lookup.ContainsKey(vi.PositionIndex))
{
v = new ModelVertex(position: positions[vi.PositionIndex]);
if ((vertexFormat & VertexFormat.Normal) == VertexFormat.Normal && face.Vertexes[i].Normal >= 0)
{
vi.NormalIndex = face.Vertexes[i].Normal;
v.Normal = normals[vi.NormalIndex];
}
if ((vertexFormat & VertexFormat.TexCoord) == VertexFormat.TexCoord && face.Vertexes[i].TexCoord >= 0)
{
vi.TcIndex = face.Vertexes[i].TexCoord;
v.TexCoord = texCoords[vi.TcIndex];
}
vi.VertexIndex = vertexes.Count;
lookup.Add(vi.PositionIndex, new List <VertexInfo>()
{
vi
});
vertexes.Add(v);
vertexCount++;
indexes[k] = (uint)vi.VertexIndex;
}
else
{
//else get the list of vertices that contains that position and
// if new vertex is not in the list create the new destination vertex and add it to the VertexBuffer
var vlist = lookup[vi.PositionIndex];
if ((vertexFormat & VertexFormat.Normal) == VertexFormat.Normal)
{
vi.NormalIndex = face.Vertexes[i].Normal;
}
if ((vertexFormat & VertexFormat.TexCoord) == VertexFormat.TexCoord)
{
vi.TcIndex = face.Vertexes[i].TexCoord;
}
int index = vlist.FindIndex(x => x.Equals(vi));
if (index < 0)
{
v = new ModelVertex(positions[vi.PositionIndex]);
if (vi.NormalIndex >= 0)
{
v.Normal = normals[vi.NormalIndex];
}
if (vi.TcIndex >= 0)
{
v.TexCoord = texCoords[vi.TcIndex];
}
vi.VertexIndex = vertexes.Count;
indexes[k] = (uint)vi.VertexIndex;
vertexCount++;
vertexes.Add(v);
vlist.Add(vi);
}
else
{
//else the vertex is already in the VertexBuffer so create add the vertex index
//to the indexbuffer
vi = vlist[index];
indexes[k] = (uint)vi.VertexIndex;
}
}
k++;
startVertex = Math.Min(startVertex, vi.VertexIndex);
}
}
#endregion Faces
meshLayer.startVertex = startVertex;
meshLayer.vertexCount = vertexCount;
layers.Add(meshLayer);
}
#endregion Layers
mesh.SetLayers(layers.ToArray());
var data = vertexes.ToArray();
mesh.CreateVertexBuffer(data);
if (mesh.VertexCount < ushort.MaxValue)
{
mesh.CreateIndexBuffer(indexes.Select(x => (ushort)x).ToArray());
}
else
{
mesh.CreateIndexBuffer(indexes);
}
mesh.DefragmentLayers();
mesh.BlendLayers();
if ((vertexFormat & VertexFormat.Normal) != VertexFormat.Normal)
{
mesh.ComputeNormals();
}
if ((vertexFormat & VertexFormat.TexCoord) != VertexFormat.TexCoord)
{
mesh.ComputeTextureCoords(CoordMappingType.Spherical);
}
mesh.ComputeTangents();
nodes.Add(new SceneNode <MeshInstance>(g.Name, new MeshInstance(meshMaterials.ToArray(), mesh)));
vertexes.Clear();
//test
lookup.Clear();
}
#endregion
QuadTreeSceneNode node = new QuadTreeSceneNode(name, 10);
node.Context = new TechniqueRenderContext(node);
foreach (var item in nodes)
{
node.Add(item);
}
node.UpdateLayout();
var package = new EngineContent(name);
package.Providers.AddRange(sceneMaterials);
package.Providers.Add(node);
return(package);
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
Content cont;
switch (layer)
{
case MeshLayer.StaticMaterial:
case MeshLayer.StaticCutout:
if (materialMatcher.Get(tile.material, out cont))
{
value = cont.GetValue(tile, layer);
return(true);
}
break;
case MeshLayer.BaseMaterial:
case MeshLayer.BaseCutout:
if (materialMatcher.Get(tile.base_material, out cont))
{
value = cont.GetValue(tile, layer);
return(true);
}
break;
case MeshLayer.LayerMaterial:
case MeshLayer.LayerCutout:
if (materialMatcher.Get(tile.layer_material, out cont))
{
value = cont.GetValue(tile, layer);
return(true);
}
break;
case MeshLayer.VeinMaterial:
case MeshLayer.VeinCutout:
if (materialMatcher.Get(tile.vein_material, out cont))
{
value = cont.GetValue(tile, layer);
return(true);
}
break;
case MeshLayer.NoMaterial:
case MeshLayer.NoMaterialCutout:
if (defaultMaterial == null)
{
break;
}
value = defaultMaterial.GetValue(tile, layer);
return(true);
case MeshLayer.Growth0Cutout:
break;
case MeshLayer.Growth1Cutout:
break;
case MeshLayer.Growth2Cutout:
break;
case MeshLayer.Growth3Cutout:
break;
default:
break;
}
value = default(T);
return(false);
}
void FillMeshBuffer(out MeshCombineUtility.MeshInstance buffer, MeshLayer layer, MapTile tile)
{
buffer = new MeshCombineUtility.MeshInstance();
MeshContent content = null;
if (!contentLoader.tileMeshConfiguration.GetValue(tile, layer, out content))
{
buffer.mesh = null;
return;
}
buffer.mesh = content.mesh[(int)layer];
buffer.transform = Matrix4x4.TRS(DFtoUnityCoord(tile.position), Quaternion.identity, Vector3.one);
if (tile != null)
{
int tileTexIndex = 0;
IndexContent tileTexContent;
if (contentLoader.tileTextureConfiguration.GetValue(tile, layer, out tileTexContent))
{
tileTexIndex = tileTexContent.value;
}
int matTexIndex = 0;
IndexContent matTexContent;
if (contentLoader.materialTextureConfiguration.GetValue(tile, layer, out matTexContent))
{
matTexIndex = matTexContent.value;
}
ColorContent newColorContent;
Color newColor;
if (contentLoader.colorConfiguration.GetValue(tile, layer, out newColorContent))
{
newColor = newColorContent.value;
}
else
{
MatPairStruct mat;
mat.mat_type = -1;
mat.mat_index = -1;
switch (layer)
{
case MeshLayer.StaticMaterial:
case MeshLayer.StaticCutout:
mat = tile.material;
break;
case MeshLayer.BaseMaterial:
case MeshLayer.BaseCutout:
mat = tile.base_material;
break;
case MeshLayer.LayerMaterial:
case MeshLayer.LayerCutout:
mat = tile.layer_material;
break;
case MeshLayer.VeinMaterial:
case MeshLayer.VeinCutout:
mat = tile.vein_material;
break;
case MeshLayer.NoMaterial:
case MeshLayer.NoMaterialCutout:
break;
case MeshLayer.Growth0Cutout:
break;
case MeshLayer.Growth1Cutout:
break;
case MeshLayer.Growth2Cutout:
break;
case MeshLayer.Growth3Cutout:
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.white;
}
}
buffer.color = newColor;
buffer.uv1Index = matTexIndex;
buffer.uv2Index = tileTexIndex;
}
}
/// <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);
}
bool GenerateTiles(int block_x, int block_y, int block_z)
{
if (!blockDirtyBits[block_x, block_y, block_z])
{
return(true);
}
blockDirtyBits[block_x, block_y, block_z] = false;
int bufferIndex = 0;
int stencilBufferIndex = 0;
for (int xx = (block_x * blockSize); xx < (block_x + 1) * blockSize; xx++)
{
for (int yy = (block_y * blockSize); yy < (block_y + 1) * blockSize; yy++)
{
////do lights first
//if (tiles[xx, yy, block_z] != null)
//{
// //do magma lights
// if ((xx % 1 == 0) && (yy % 1 == 0) && (block_z % 1 == 0))
// if (tiles[xx, yy, block_z].magma > 0 && magmaGlow[xx, yy, block_z] == null)
// {
// magmaGlow[xx, yy, block_z] = (Light)Instantiate(magmaGlowPrefab);
// magmaGlow[xx, yy, block_z].gameObject.SetActive(true);
// magmaGlow[xx, yy, block_z].transform.parent = this.transform;
// magmaGlow[xx, yy, block_z].transform.position = DFtoUnityCoord(xx, yy, block_z + 1);
// }
//}
if (meshBuffer == null)
{
meshBuffer = new MeshCombineUtility.MeshInstance[blockSize * blockSize * (int)MeshLayer.StaticCutout];
}
if (stencilMeshBuffer == null)
{
stencilMeshBuffer = new MeshCombineUtility.MeshInstance[blockSize * blockSize * ((int)MeshLayer.Count - (int)MeshLayer.StaticCutout)];
}
for (int i = 0; i < (int)MeshLayer.Count; i++)
{
MeshLayer layer = (MeshLayer)i;
switch (layer)
{
case MeshLayer.StaticMaterial:
case MeshLayer.BaseMaterial:
case MeshLayer.LayerMaterial:
case MeshLayer.VeinMaterial:
case MeshLayer.NoMaterial:
FillMeshBuffer(out meshBuffer[bufferIndex], layer, tiles[xx, yy, block_z]);
bufferIndex++;
break;
case MeshLayer.StaticCutout:
case MeshLayer.BaseCutout:
case MeshLayer.LayerCutout:
case MeshLayer.VeinCutout:
case MeshLayer.Growth0Cutout:
case MeshLayer.Growth1Cutout:
case MeshLayer.Growth2Cutout:
case MeshLayer.Growth3Cutout:
case MeshLayer.NoMaterialCutout:
FillMeshBuffer(out stencilMeshBuffer[stencilBufferIndex], layer, tiles[xx, yy, block_z]);
stencilBufferIndex++;
break;
default:
break;
}
}
}
}
if (blocks[block_x, block_y, block_z] == null)
{
GameObject block = Instantiate(defaultMapBlock) as GameObject;
block.SetActive(true);
block.transform.parent = this.transform;
block.name = "terrain(" + block_x + ", " + block_y + ", " + block_z + ")";
blocks[block_x, block_y, block_z] = block.GetComponent <MeshFilter>();
}
MeshFilter mf = blocks[block_x, block_y, block_z];
if (mf == null)
{
Debug.LogError("MF is null");
}
if (mf.mesh == null)
{
mf.mesh = new Mesh();
}
mf.mesh.Clear();
//mf.mesh.CombineMeshes(meshBuffer);
if (stencilBlocks[block_x, block_y, block_z] == null)
{
GameObject stencilBlock = Instantiate(defaultStencilMapBLock) as GameObject;
stencilBlock.SetActive(true);
stencilBlock.transform.parent = this.transform;
stencilBlock.name = "foliage(" + block_x + ", " + block_y + ", " + block_z + ")";
stencilBlocks[block_x, block_y, block_z] = stencilBlock.GetComponent <MeshFilter>();
}
MeshFilter mfs = stencilBlocks[block_x, block_y, block_z];
if (mfs == null)
{
Debug.LogError("MFS is null");
}
if (mfs.mesh == null)
{
mfs.mesh = new Mesh();
}
mfs.mesh.Clear();
MeshCombineUtility.ColorCombine(mfs.mesh, stencilMeshBuffer);
return(MeshCombineUtility.ColorCombine(mf.mesh, meshBuffer));
//Debug.Log("Generated a mesh with " + (mf.mesh.triangles.Length / 3) + " tris");
}
internal void GetValue(MapDataStore.Tile tempTile, MeshLayer staticMaterial, out object colorContent)
{
throw new NotImplementedException();
}
//Dictionary<string, Texture2D> diffuseTextures = new Dictionary<string, Texture2D>();
//Dictionary<string, Texture2D> specularTextures = new Dictionary<string, Texture2D>();
//Dictionary<string, geometry> geometryLibrary = new Dictionary<string, geometry>();
//List<node> nodeList = new List<node>();
//this is very similar to the blockmesher function.
void CollectModel(MapDataStore.Tile tile, MeshLayer layer, DFCoord pos)
{
if (layer == MeshLayer.Collision || layer == MeshLayer.BuildingCollision)
return;
#region Mesh Selection
MeshContent meshContent = null;
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))
return;
break;
default:
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))
return;
if (!ContentLoader.Instance.BuildingMeshConfiguration.GetValue(tile, layer, out meshContent))
return;
}
break;
default:
{
if (!ContentLoader.Instance.TileMeshConfiguration.GetValue(tile, layer, out meshContent))
return;
}
break;
}
if (!meshContent.MeshData.ContainsKey(layer))
return;
#endregion
node tileNode = new node();
tileNode.id = string.Format("Tile[{0},{1},{2}]_{3}", pos.x, pos.y, pos.z, layer);
tileNode.Items = new object[]
{
COLLADA.ConvertMatrix(Matrix4x4.TRS(
GameMap.DFtoUnityCoord(pos),
meshContent.GetRotation(tile),
Vector3.one))
};
tileNode.ItemsElementName = new ItemsChoiceType2[] { ItemsChoiceType2.matrix };
//string geometryName = "Mesh-" + meshContent.UniqueIndex;
//if (!geometryLibrary.ContainsKey(geometryName))
//{
// geometryLibrary[geometryName] = COLLADA.MeshToGeometry(meshContent.MeshData[layer], geometryName);
//}
//instance_geometry geometryInstance = new instance_geometry();
//geometryInstance.url = "#" + geometryLibrary[geometryName].id;
//tileNode.instance_geometry = new instance_geometry[] { geometryInstance };
//nodeList.Add(tileNode);
//return;
//-----------------------------------------------------------
//Put normal map stuff here! Remember!
//-----------------------------------------------------------
//string patternName = "Tex-";
//Texture2D tiletexture = null;
//TextureContent textureContent;
//if (ContentLoader.Instance.MaterialTextureConfiguration.GetValue(tile, layer, out textureContent))
//{
// tiletexture = textureContent.Texture;
// patternName += textureContent.UniqueIndex;
//}
//else patternName += "#";
//patternName += "-#";
//Color color = Color.grey;
//ColorContent colorContent;
//if (ContentLoader.Instance.ColorConfiguration.GetValue(tile, layer, out colorContent))
//{
// color = colorContent.color;
//}
//patternName += string.Format("{0:X2}{1:X2}{2:X2}", ((Color32)color).r, ((Color32)color).g, ((Color32)color).b);
//if (diffuseTextures.ContainsKey(patternName))
// return;
//Color neutralSpec = new Color(0.04f, 0.04f, 0.04f);
//Texture2D outputDiffuse;
//Texture2D outputSpec;
//if (tiletexture != null)
//{
// outputDiffuse = new Texture2D(tiletexture.width, tiletexture.height);
// outputSpec = new Texture2D(tiletexture.width, tiletexture.height);
// Color[] colors = tiletexture.GetPixels();
// Color[] specs = new Color[colors.Length];
// for (int i = 0; i < colors.Length; i++)
// {
// var diffuseColor = OverlayBlend(colors[i], color);
// diffuseColor.a = 1;
// colors[i] = Color.Lerp(Color.black, diffuseColor, color.a);
// specs[i] = Color.Lerp(diffuseColor, neutralSpec, color.a);
// }
// outputDiffuse.SetPixels(colors);
// outputSpec.SetPixels(specs);
//}
//else
//{
// outputDiffuse = ContentLoader.CreateFlatTexture(color);
// outputSpec = ContentLoader.CreateFlatTexture(neutralSpec);
//}
//outputDiffuse.name = patternName + "_Diffuse";
//outputSpec.name = patternName + "_Specular";
//diffuseTextures[patternName] = outputDiffuse;
//specularTextures[patternName] = outputSpec;
}
public override bool GetValue(MapDataStore.Tile tile, MeshLayer layer, out T value)
{
//let's just get rid of dead trees right away
if (tile.special == TiletypeSpecial.DEAD ||
tile.special == TiletypeSpecial.SMOOTH_DEAD)
{
value = default(T);
return(false);
}
int growthLayer = int.MaxValue;
switch (layer)
{
case MeshLayer.GrowthMaterial:
case MeshLayer.GrowthCutout:
case MeshLayer.GrowthTransparent:
growthLayer = 0;
break;
case MeshLayer.GrowthMaterial1:
case MeshLayer.GrowthCutout1:
case MeshLayer.GrowthTransparent1:
growthLayer = 1;
break;
case MeshLayer.GrowthMaterial2:
case MeshLayer.GrowthCutout2:
case MeshLayer.GrowthTransparent2:
growthLayer = 2;
break;
case MeshLayer.GrowthMaterial3:
case MeshLayer.GrowthCutout3:
case MeshLayer.GrowthTransparent3:
growthLayer = 3;
break;
default:
break;
}
MatPairStruct mat = tile.material;
if (mat.mat_type != PlantType ||
mat.mat_index < 0 ||
DFConnection.Instance.NetPlantRawList == null ||
DFConnection.Instance.NetPlantRawList.plant_raws.Count <= mat.mat_index ||
DFConnection.Instance.NetPlantRawList.plant_raws[mat.mat_index].growths.Count <= growthLayer)
{
value = default(T);
return(false);
}
TreeGrowth growth = DFConnection.Instance.NetPlantRawList.plant_raws[mat.mat_index].growths[growthLayer];
if (!tile.GrowthAppliesNow(growth))
{
value = default(T);
return(false);
}
int currentTicks = TimeHolder.DisplayedTime.CurrentYearTicks;
GrowthPrint print = null;
int printIndex = 0;
for (int i = 0; i < growth.prints.Count; i++)
{
var tempPrint = growth.prints[i];
if (!((tempPrint.timing_start != -1 && tempPrint.timing_start > currentTicks) || (tempPrint.timing_end != -1 && tempPrint.timing_end < currentTicks)))
{
print = tempPrint;
printIndex = i;
}
}
if (print == null)
{
value = default(T);
return(false);
}
BuildingStruct growthIndex = new BuildingStruct(mat.mat_index, growthLayer, printIndex);
Content cont;
if (growthMatcher.TryGetValue(growthIndex, out cont))
{
value = cont.GetValue(tile, layer);
return(true);
}
value = default(T);
return(false);
}
private SkelletalMesh GetMesh(GMeshContainer meshContainer, Bone root, VertexDescriptor vd)
{
SlimDX.Direct3D9.Mesh d3dMesh = meshContainer.Mesh;
var adjacency = meshContainer.GetAdjacency();
var meshMaterials = meshContainer.GetMaterials();
List <MeshMaterial> materials = new List <MeshMaterial>();
for (int i = 0; i < meshMaterials.Length; i++)
{
var matd3d = meshMaterials[i].MaterialD3D;
string textureFilename = meshMaterials[i].TextureFileName;
if (textureFilename != null && !Path.IsPathRooted(textureFilename))
{
textureFilename = Path.Combine(Path.GetDirectoryName(xFile), textureFilename);
}
materials.Add(new MeshMaterial()
{
Name = root.Name + "_material" + i,
Alpha = matd3d.Diffuse.Alpha,
Diffuse = matd3d.Diffuse.ToVector3(),
Specular = matd3d.Specular.ToVector3(),
SpecularPower = Math.Max(1, matd3d.Power),
Reflectivity = 0,
Refractitity = 0,
EmissiveColor = matd3d.Emissive.ToVector3(),
DiffuseMap = textureFilename
});
}
SkelletalMesh mesh = new SkelletalMesh(vd);
mesh.Adjacency = adjacency;
SkinVertex[] vertexes = new SkinVertex[d3dMesh.VertexCount];
Array indices;
if (d3dMesh.IndexBuffer.Description.Format == Format.Index16)
{
indices = new ushort[d3dMesh.FaceCount * 3];
}
else
{
indices = new uint[d3dMesh.FaceCount * 3];
}
VertexDescriptor meshVD = new VertexDescriptor(d3dMesh.GetDeclaration());
int positionOffset = meshVD.GetOffset(DeclarationUsage.Position, 0);
int normalOffset = meshVD.GetOffset(DeclarationUsage.Normal, 0);
int texCoordOffset = meshVD.GetOffset(DeclarationUsage.TextureCoordinate, 0);
int blendIndicesOffset = meshVD.GetOffset(DeclarationUsage.BlendIndices, 0);
int blendIndicesSize = meshVD.SizeOfElement(DeclarationUsage.BlendIndices, 0);
int blendWeightsOffset = meshVD.GetOffset(DeclarationUsage.BlendWeight, 0);
int blendWeightSize = meshVD.SizeOfElement(DeclarationUsage.BlendWeight, 0);
byte[] buffer;
unsafe
{
DataStream vertexStream = d3dMesh.LockVertexBuffer(0);
buffer = new byte[vertexStream.Length];
vertexStream.Read(buffer, 0, (int)vertexStream.Length);
fixed(byte *_pter = buffer)
{
fixed(SkinVertex *pVertexes = vertexes)
{
byte *pter = _pter;
int j = 0;
for (int i = 0; i < d3dMesh.VertexCount; i++)
{
pVertexes[i].Position = *((Vector3 *)(pter + positionOffset));
if (normalOffset >= 0)
{
pVertexes[i].Normal = *((Vector3 *)(pter + normalOffset));
}
if (texCoordOffset >= 0)
{
pVertexes[i].TexCoord = *((Vector2 *)(pter + texCoordOffset));
}
if (blendIndicesOffset >= 0)
{
byte *indicesPter = (pter + blendIndicesOffset);
uint *pDest = (uint *)&(pVertexes[i].BlendIndices);
for (j = 0; j < blendIndicesSize; j++)
{
*(((byte *)pDest) + j) = *(indicesPter + j);
}
}
if (blendWeightsOffset >= 0)
{
byte * weightsPter = (pter + blendWeightsOffset);
Vector4 *pDest = &(pVertexes[i].BlendWeights);
for (j = 0; j < blendWeightSize; j++)
{
*(((byte *)pDest) + j) = *(weightsPter + j);
}
}
pter += d3dMesh.BytesPerVertex;
}
}
}
d3dMesh.UnlockVertexBuffer();
DataStream indexStream = d3dMesh.LockIndexBuffer(0);
GCHandle handler = GCHandle.Alloc(indices, GCHandleType.Pinned);
IntPtr indexPter = Marshal.UnsafeAddrOfPinnedArrayElement(indices, 0);
buffer = new byte[indexStream.Length];
indexStream.Read(buffer, 0, (int)indexStream.Length);
Marshal.Copy(buffer, 0, indexPter, buffer.Length);
handler.Free();
d3dMesh.UnlockIndexBuffer();
}
mesh.CreateVertexBuffer(vertexes);
if (d3dMesh.IndexBuffer.Description.Format == Format.Index16)
{
mesh.CreateIndexBuffer((ushort[])indices);
}
else
{
mesh.CreateIndexBuffer((uint[])indices);
}
List <MeshLayer> layers = new List <MeshLayer>();
if (meshContainer.BoneCombinations == null || meshContainer.BoneCombinations.Length == 0)
{
MeshLayer component = new MeshLayer();
materials.Add(MeshMaterial.CreateDefaultMaterial(meshContainer.Name + "_default"));
component.materialIndex = 0;
component.primitiveCount = mesh.FaceCount;
component.startIndex = 0;
component.startVertex = 0;
component.vertexCount = mesh.VertexCount;
layers.Add(component);
}
else
{
for (int i = 0; i < meshContainer.BoneCombinations.Length; i++)
{
BoneCombination comb = meshContainer.BoneCombinations[i];
MeshLayer component = new MeshLayer();
component.materialIndex = comb.AttributeId;
component.primitiveCount = comb.FaceCount;
component.startIndex = comb.FaceStart * 3;
component.startVertex = comb.VertexStart;
component.vertexCount = comb.VertexCount;
layers.Add(component);
}
}
var layerArray = layers.ToArray();
mesh.Materials = materials.ToArray();
mesh.SetLayers(layerArray);
var skinInfo = meshContainer.SkinInfo;
mesh.MaxVertexInfluences = skinInfo.MaximumVertexInfluences;
var bones = new Bone[skinInfo.BoneCount];
var boneOffsetMatrices = new Matrix[bones.Length];
for (int i = 0; i < bones.Length; i++)
{
bones[i] = root.FindChild(skinInfo.GetBoneName(i));
boneOffsetMatrices[i] = skinInfo.GetBoneOffsetMatrix(i);
}
mesh.Bones = bones;
mesh.BoneBindingMatrices = boneOffsetMatrices;
if (meshContainer.BoneCombinations != null && meshContainer.BoneCombinations.Length > 0)
{
for (int layerIndex = 0; layerIndex < layerArray.Length; layerIndex++)
{
mesh.SetLayerBones(layerIndex, meshContainer.BoneCombinations[layerIndex].BoneIds);
}
}
mesh.LockVertexBuffer();
int[] vertices;
float[] weights;
for (int i = 0; i < mesh.bones.Length; i++)
{
skinInfo.GetBoneInfluence(i, out vertices, out weights);
VertexStreamView <Vector3> positions = mesh.GetVertexViewStream <Vector3>(DeclarationUsage.Position, 0, vertices);
}
mesh.UnlockVertexBuffer();
meshVD.Dispose();
if (normalOffset < 0)
{
mesh.ComputeNormals();
}
if (texCoordOffset < 0)
{
mesh.ComputeTextureCoords(CoordMappingType.Spherical);
}
mesh.ComputeTangents();
return(mesh);
}
internal HeaderSectionInfo LoadHeader(EndianBinaryReader input, MeshLayer newLayer)
{
Layer = newLayer;
uint renderFlagsUint = input.ReadUInt32();
if ((renderFlagsUint & ~(uint)(RenderFlag.UnkFlag01 |
RenderFlag.TwoSided |
RenderFlag.UnkFlag04 |
RenderFlag.UnkFlag08 |
RenderFlag.UnkFlag10 |
RenderFlag.UnkFlag20 |
RenderFlag.UnkFlag40 |
RenderFlag.UnkFlag200)) != 0)
{
throw new InvalidOperationException("Unknown RenderFlags set.");
}
RenderFlags = (RenderFlag)renderFlagsUint;
Unk4 = input.ReadUInt32();
Unk8 = input.ReadUInt32();
UnkC = input.ReadUInt32();
Unk10 = input.ReadUInt16();
byte usedMaterialCount = input.ReadByte();
byte sectionFlags = input.ReadByte();
Unk14 = input.ReadUInt16();
PrimaryMaterialIdx = input.ReadUInt16();
SecondaryMaterialIdx = input.ReadUInt16();
TertiaryMaterialIdx = input.ReadUInt16();
int calculatedUsedMaterialCount = (byte)(
((PrimaryMaterialIdx != ushort.MaxValue) ? 1 : 0) +
((SecondaryMaterialIdx != ushort.MaxValue) ? 1 : 0) +
((TertiaryMaterialIdx != ushort.MaxValue) ? 1 : 0));
if (calculatedUsedMaterialCount != usedMaterialCount)
{
throw new InvalidOperationException("Expected GcmfTriangleMesh[0x13] to match used material count.");
}
uint vertexFlags = input.ReadUInt32();
input.Read(TransformMatrixSpecificIdxsObj1, 0, 8);
int chunk1Size = input.ReadInt32();
int chunk2Size = input.ReadInt32();
BoundingSphereCenter = new Vector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
Unk3C = input.ReadSingle();
Unk40 = input.ReadUInt32();
if (input.ReadUInt32() != 0)
{
throw new InvalidGmaFileException("Expected GcmfTriangleMesh[0x44] == 0");
}
if (input.ReadUInt32() != 0)
{
throw new InvalidGmaFileException("Expected GcmfTriangleMesh[0x48] == 0");
}
if (input.ReadUInt32() != 0)
{
throw new InvalidGmaFileException("Expected GcmfTriangleMesh[0x4C] == 0");
}
if (input.ReadUInt32() != 0)
{
throw new InvalidGmaFileException("Expected GcmfTriangleMesh[0x50] == 0");
}
if (input.ReadUInt32() != 0)
{
throw new InvalidGmaFileException("Expected GcmfTriangleMesh[0x54] == 0");
}
if (input.ReadUInt32() != 0)
{
throw new InvalidGmaFileException("Expected GcmfTriangleMesh[0x58] == 0");
}
if (input.ReadUInt32() != 0)
{
throw new InvalidGmaFileException("Expected GcmfTriangleMesh[0x5C] == 0");
}
return(new HeaderSectionInfo
{
SectionFlags = sectionFlags,
VertexFlags = vertexFlags,
Chunk1Size = chunk1Size,
Chunk2Size = chunk2Size
});
}
/// <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);
}
