public AutoTile GetSanitizedTile(Loc offset)
{
if (autotile > -1)
{
AutoTile auto = new AutoTile(autotile, associates);
return(auto);
}
TileLayer newLayer = new TileLayer();
bool hasFilled = false;
foreach (TileFrame frame in layer.Frames)
{
TileFrame newFrame = new TileFrame(frame.TexLoc + offset, frame.Sheet);
//check for emptiness
long tilePos = GraphicsManager.TileIndex.GetPosition(newFrame.Sheet, newFrame.TexLoc);
if (tilePos > 0)
{
newLayer.Frames.Add(newFrame);
hasFilled = true;
}
else
{
newLayer.Frames.Add(TileFrame.Empty);
}
}
if (!hasFilled)
{
return(new AutoTile());
}
newLayer.FrameLength = layer.FrameLength;
return(new AutoTile(newLayer));
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
TileFrame tileFrame = (TileFrame)value;
if (tileFrame.Sheet == null)
{
return(null);
}
return(DevGraphicsManager.GetTile(tileFrame));
}
public static void GridDimensions()
{
for (int y = 0; y < TileFrame.GetLength(1); y++)
{
for (int x = 0; x < TileFrame.GetLength(0); x++)
{
TileFrame[x, y] = new Rectangle(
(x * CurrentTileSize) + Player.player.TileOffsetXY[0],
(y * CurrentTileSize) + Player.player.TileOffsetXY[1],
CurrentTileSize, CurrentTileSize);
}
}
}
public static Bitmap GetTile(TileFrame tileTex)
{
long tilePos = GraphicsManager.TileIndex.GetPosition(tileTex.Sheet, tileTex.TexLoc);
TileAddr addr = new TileAddr(tilePos, tileTex.Sheet);
Bitmap sheet;
if (tileCache.TryGetValue(addr, out sheet))
{
return(sheet);
}
if (tilePos > 0)
{
try
{
using (FileStream stream = new FileStream(PathMod.ModPath(String.Format(GraphicsManager.TILE_PATTERN, tileTex.Sheet)), FileMode.Open, FileAccess.Read, FileShare.Read))
{
// Seek to the location of the tile
stream.Seek(tilePos, SeekOrigin.Begin);
using (BinaryReader reader = new BinaryReader(stream))
{
//usually handled by basesheet, cheat a little here
long length = reader.ReadInt64();
byte[] tileBytes = reader.ReadBytes((int)length);
using (MemoryStream tileStream = new MemoryStream(tileBytes))
sheet = new Bitmap(tileStream);
}
}
tileCache.Add(addr, sheet);
return(sheet);
}
catch (Exception ex)
{
DiagManager.Instance.LogError(new Exception("Error retrieving tile " + tileTex.TexLoc.X + ", " + tileTex.TexLoc.Y + " from Tileset #" + tileTex.Sheet + "\n", ex));
}
}
return(null);
}
public static BaseSheet GetTile(TileFrame tileTex)
{
BaseSheet sheet;
if (tileCache.TryGetValue(tileTex, out sheet))
{
return(sheet);
}
long tilePos = TileIndex.GetPosition(tileTex.Sheet, tileTex.TexLoc);
if (tilePos > 0)
{
try
{
using (FileStream stream = new FileStream(String.Format(TILE_PATTERN, tileTex.Sheet), FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (BinaryReader reader = new BinaryReader(stream))
{
// Seek to the location of the tile
reader.BaseStream.Seek(tilePos, SeekOrigin.Begin);
sheet = BaseSheet.Load(reader);
tileCache.Add(tileTex, sheet);
return(sheet);
}
}
}
catch (Exception ex)
{
DiagManager.Instance.LogError(new Exception("Error retrieving tile " + tileTex.TexLoc.X + ", " + tileTex.TexLoc.Y + " from Tileset #" + tileTex.Sheet + "\n", ex));
}
}
BaseSheet newSheet = BaseSheet.LoadError();
tileCache.Add(tileTex, newSheet);
return(newSheet);
}
internal void ConvertTile(Tile tile, List <TileEntry> entries, out ushort type)
{
var frame = new TileFrame(tile.frameX, tile.frameY);
int frameID = frame.FrameID;
if (converted.TryGetValue(frameID, out type))
{
return;
}
TileInfo info = infos[frameID];
var entry = new TileEntry(TileLoader.GetTile(tile.type))
{
name = info.name,
modName = info.modName,
frameImportant = info.frameX > -1,
type = type = (ushort)entries.Count
};
entries.Add(entry);
converted.Add(frameID, type);
}
private void ConstructTiles(OriginalImage source, TileType tileType)
{
Tiles = new ObservableCollection<Tile>();
//break it down into x-number pixel square tiles
for (var tileRow = 0; tileRow < source.Height / Constants.TILE_PIXELS; tileRow++)
{
for (var tileColumn = 0; tileColumn < Constants.UNMANAGED_TILE_PIXEL_WIDTH / Constants.TILE_PIXELS; tileColumn++)
{
//we want to go one frame at a time
var tile = new Tile() { Type = tileType };
for (var frame = 0; frame * Constants.UNMANAGED_TILE_PIXEL_WIDTH < source.Width; frame++)
{
var tileFrame = new TileFrame();
var newBytes = new List<Byte>();
for (var row = 0; row < Constants.TILE_PIXELS; row++)
{
//for each row of this tile, grab the pixels from imagebytes
var totalRowOffset = tileRow * Constants.TILE_PIXELS + row;
var totalColumnOffset = Constants.UNMANAGED_TILE_PIXEL_WIDTH * frame + tileColumn * Constants.TILE_PIXELS;
var offset = source.CalculateImageByteArrayOffset(totalRowOffset, totalColumnOffset);
newBytes.AddRange(source.ImageBytes.Skip(offset).Take(4 * Constants.TILE_PIXELS)); //4 bytes per tile
}
tileFrame.SetSource(Constants.TILE_PIXELS, Constants.TILE_PIXELS, newBytes.ToArray());
tile.Frames.Add(tileFrame);
}
Tiles.Add(tile);
}
}
}
public bool IsInside(Point point)
{
return(TileFrame.IsInside(point));
}
private StringWriter BuildObjString()
{
// Creates the text for a Wavefront OBJ file for the TmxMap
StringWriter objWriter = new StringWriter();
// Gather the information for every face
var faces = from layer in this.tmxMap.Layers
where layer.Visible == true
where layer.Properties.GetPropertyValueAsBoolean("unity:collisionOnly", false) == false
// Draw order forces us to visit tiles in a particular order
from y in (this.tmxMap.DrawOrderVertical == 1) ? Enumerable.Range(0, layer.Height) : Enumerable.Range(0, layer.Height).Reverse()
from x in (this.tmxMap.DrawOrderHorizontal == 1) ? Enumerable.Range(0, layer.Width) : Enumerable.Range(0, layer.Width).Reverse()
let rawTileId = layer.GetRawTileIdAt(x, y)
let tileId = TmxMath.GetTileIdWithoutFlags(rawTileId)
where tileId != 0
let fd = TmxMath.IsTileFlippedDiagonally(rawTileId)
let fh = TmxMath.IsTileFlippedHorizontally(rawTileId)
let fv = TmxMath.IsTileFlippedVertically(rawTileId)
let animTile = this.tmxMap.Tiles[tileId]
// Enumerate through all frames of a tile. (Tiles without animation are treated as a single frame)
from frame in TileFrame.EnumerateFramesFromTile(animTile, this.tmxMap)
select new
{
LayerName = layer.UniqueName,
Vertices = CalculateFaceVertices(this.tmxMap.GetMapPositionAt(x, y), frame.Tile.TileSize, this.tmxMap.TileHeight, frame.Position_z),
TextureCoordinates = CalculateFaceTextureCoordinates(frame.Tile, fd, fh, fv),
ImagePath = frame.Tile.TmxImage.Path,
ImageName = Path.GetFileNameWithoutExtension(frame.Tile.TmxImage.Path),
};
// We have all the information we need now to build our list of vertices, texture coords, and grouped faces
// (Faces are grouped by LayerName.TextureName combination because Wavefront Obj only supports one texture per face)
objWriter.WriteLine("# Wavefront OBJ file automatically generated by Tiled2Unity");
objWriter.WriteLine();
// We may have a ton of vertices so use a set right now
HashSet <Vector3D> vertexSet = new HashSet <Vector3D>();
Program.WriteLine("Building face vertices");
foreach (var face in faces)
{
// Index the vertices
foreach (var v in face.Vertices)
{
vertexSet.Add(v);
}
}
HashSet <PointF> textureCoordinateSet = new HashSet <PointF>();
Program.WriteLine("Building face texture coordinates");
foreach (var face in faces)
{
// Index the texture coordinates
foreach (var tc in face.TextureCoordinates)
{
textureCoordinateSet.Add(tc);
}
}
// Write the indexed vertices
Program.WriteLine("Writing indexed vertices");
IList <Vector3D> vertices = vertexSet.ToList();
objWriter.WriteLine("# Vertices (Count = {0})", vertices.Count);
foreach (var v in vertices)
{
objWriter.WriteLine("v {0} {1} {2}", v.X, v.Y, v.Z);
}
objWriter.WriteLine();
// Write the indexed texture coordinates
Program.WriteLine("Writing indexed texture coordinates");
IList <PointF> textureCoordinates = textureCoordinateSet.ToList();
objWriter.WriteLine("# Texture Coorindates (Count = {0})", textureCoordinates.Count);
foreach (var vt in textureCoordinates)
{
objWriter.WriteLine("vt {0} {1}", vt.X, vt.Y);
}
objWriter.WriteLine();
// Write the one indexed normal
objWriter.WriteLine("# Normal");
objWriter.WriteLine("vn 0 0 -1");
objWriter.WriteLine();
// Group faces by Layer+TileSet
var groups = from f in faces
group f by TiledMapExpoterUtils.UnityFriendlyMeshName(tmxMap, f.LayerName, f.ImageName);
// Write out the faces
objWriter.WriteLine("# Groups (Count = {0})", groups.Count());
// Need dictionaries with index as value.
var vertexDict = Enumerable.Range(0, vertices.Count()).ToDictionary(i => vertices[i], i => i);
var texCoordDict = Enumerable.Range(0, textureCoordinates.Count()).ToDictionary(i => textureCoordinates[i], i => i);
foreach (var g in groups)
{
Program.WriteLine("Writing '{0}' mesh group", g.Key);
objWriter.WriteLine("g {0}", g.Key);
foreach (var f in g)
{
objWriter.Write("f ");
for (int i = 0; i < 4; ++i)
{
int vertexIndex = vertexDict[f.Vertices[i]] + 1;
int textureCoordinateIndex = texCoordDict[f.TextureCoordinates[i]] + 1;
objWriter.Write(" {0}/{1}/1 ", vertexIndex, textureCoordinateIndex);
}
objWriter.WriteLine();
}
}
Program.WriteLine("Done writing Wavefront Obj data for '{0}'", tmxMap.Name);
return(objWriter);
}
