/// <summary>
/// Copy a subtileset source textures in the atlas
/// </summary>
/// <param name="autoTileset"></param>
/// <param name="tilesetConf"></param>
public static void CopySubTilesetInAtlas( AutoTileset autoTileset, SubTilesetConf tilesetConf )
{
//+++ old values for 32x32 tiles, now depend on tile size
int _768 = 24 * autoTileset.TileWidth;
int _640 = 20 * autoTileset.TileWidth;
int _512 = 16 * autoTileset.TileWidth;
int _480 = 15 * autoTileset.TileWidth;
int _384 = 12 * autoTileset.TileWidth;
int _256 = 8 * autoTileset.TileWidth;
//---
for (int i = 0; i < tilesetConf.SourceTexture.Length; ++i )
{
ImportTexture(tilesetConf.SourceTexture[i]);
}
if (tilesetConf.HasAutotiles)
{
int xf = (int)tilesetConf.AtlasRec.x;
int yf = (int)tilesetConf.AtlasRec.y;
_CopyTilesetInAtlas(autoTileset.AtlasTexture, tilesetConf.SourceTexture[0], xf, yf, _512, _384); // animated
_CopyTilesetInAtlas(autoTileset.AtlasTexture, tilesetConf.SourceTexture[1], xf, yf+_384, _512, _384); // ground
_CopyTilesetInAtlas(autoTileset.AtlasTexture, tilesetConf.SourceTexture[2], xf, yf + _768, _512, _256); // building
_CopyTilesetInAtlas(autoTileset.AtlasTexture, tilesetConf.SourceTexture[3], xf+_512, yf, _512, _480); // wall
_CopyTilesetInAtlas(autoTileset.AtlasTexture, tilesetConf.SourceTexture[4], xf+_512, yf + _512, _256, _512); // normal
_CopyBuildingThumbnails(autoTileset, tilesetConf.SourceTexture[2], xf + _768, yf + _512);
_CopyWallThumbnails(autoTileset, tilesetConf.SourceTexture[3], xf+_768, yf+_640);
}
else
{
_CopyTilesetInAtlas(autoTileset.AtlasTexture, tilesetConf.SourceTexture[0], tilesetConf.AtlasRec); // object
}
}
/// <summary>
/// Copy a subtileset source textures in the atlas
/// </summary>
/// <param name="autoTileset"></param>
/// <param name="tilesetConf"></param>
public static void CopySubTilesetInAtlas(AutoTileset autoTileset, SubTilesetConf tilesetConf)
{
//+++ old values for 32x32 tiles, now depend on tile size
int _768 = 24 * autoTileset.TileWidth;
int _640 = 20 * autoTileset.TileWidth;
int _512 = 16 * autoTileset.TileWidth;
int _480 = 15 * autoTileset.TileWidth;
int _384 = 12 * autoTileset.TileWidth;
int _256 = 8 * autoTileset.TileWidth;
//---
for (int i = 0; i < tilesetConf.SourceTexture.Length; ++i)
{
ImportTexture(tilesetConf.SourceTexture[i]);
}
if (tilesetConf.HasAutotiles)
{
int xf = (int)tilesetConf.AtlasRec.x;
int yf = (int)tilesetConf.AtlasRec.y;
_CopyTilesetInAtlas(autoTileset.AtlasTexture, tilesetConf.SourceTexture[0], xf, yf, _512, _384); // animated
_CopyTilesetInAtlas(autoTileset.AtlasTexture, tilesetConf.SourceTexture[1], xf, yf + _384, _512, _384); // ground
_CopyTilesetInAtlas(autoTileset.AtlasTexture, tilesetConf.SourceTexture[2], xf, yf + _768, _512, _256); // building
_CopyTilesetInAtlas(autoTileset.AtlasTexture, tilesetConf.SourceTexture[3], xf + _512, yf, _512, _480); // wall
_CopyTilesetInAtlas(autoTileset.AtlasTexture, tilesetConf.SourceTexture[4], xf + _512, yf + _512, _256, _512); // normal
_CopyBuildingThumbnails(autoTileset, tilesetConf.SourceTexture[2], xf + _768, yf + _512);
_CopyWallThumbnails(autoTileset, tilesetConf.SourceTexture[3], xf + _768, yf + _640);
}
else
{
_CopyTilesetInAtlas(autoTileset.AtlasTexture, tilesetConf.SourceTexture[0], tilesetConf.AtlasRec); // object
}
}
/// <summary>
/// Generate a tileset texture for a given tilesetConf
/// </summary>
/// <param name="autoTileset"></param>
/// <param name="tilesetConf"></param>
/// <returns></returns>
public static Texture2D GenerateTilesetTexture(AutoTileset autoTileset, SubTilesetConf tilesetConf)
{
//+++ old values for 32x32 tiles, now depend on tile size
int _1024 = 32 * autoTileset.TileWidth;
int _256 = 8 * autoTileset.TileWidth;
//---
List <Rect> sprList = new List <Rect>();
FillWithTilesetThumbnailSprites(sprList, autoTileset, tilesetConf);
Texture2D tilesetTexture = new Texture2D(_256, _1024, TextureFormat.ARGB32, false);
tilesetTexture.filterMode = FilterMode.Point;
int sprIdx = 0;
Rect dstRect = new Rect(0, tilesetTexture.height - autoTileset.TileHeight, autoTileset.TileWidth, autoTileset.TileHeight);
for (; dstRect.y >= 0; dstRect.y -= autoTileset.TileHeight)
{
for (dstRect.x = 0; dstRect.x < tilesetTexture.width && sprIdx < sprList.Count; dstRect.x += autoTileset.TileWidth, ++sprIdx)
{
Rect srcRect = sprList[sprIdx];
Color[] autotileColors = autoTileset.AtlasTexture.GetPixels(Mathf.RoundToInt(srcRect.x), Mathf.RoundToInt(srcRect.y), autoTileset.TileWidth, autoTileset.TileHeight);
tilesetTexture.SetPixels(Mathf.RoundToInt(dstRect.x), Mathf.RoundToInt(dstRect.y), autoTileset.TileWidth, autoTileset.TileHeight, autotileColors);
}
}
tilesetTexture.Apply();
return(tilesetTexture);
}
/// <summary>
/// Generate a tileset texture for a given tilesetConf
/// </summary>
/// <param name="autoTileset"></param>
/// <param name="tilesetConf"></param>
/// <returns></returns>
public static Texture2D GenerateTilesetTexture( AutoTileset autoTileset, SubTilesetConf tilesetConf )
{
//+++ old values for 32x32 tiles, now depend on tile size
int _1024 = 32 * autoTileset.TileWidth;
int _256 = 8 * autoTileset.TileWidth;
//---
List<Rect> sprList = new List<Rect>();
FillWithTilesetThumbnailSprites(sprList, autoTileset, tilesetConf);
Texture2D tilesetTexture = new Texture2D( _256, _1024 );
int sprIdx = 0;
Rect dstRect = new Rect(0, tilesetTexture.height - autoTileset.TileHeight, autoTileset.TileWidth, autoTileset.TileHeight);
for (; dstRect.y >= 0; dstRect.y -= autoTileset.TileHeight)
{
for (dstRect.x = 0; dstRect.x < tilesetTexture.width && sprIdx < sprList.Count; dstRect.x += autoTileset.TileWidth, ++sprIdx)
{
Rect srcRect = sprList[sprIdx];
Color[] autotileColors = autoTileset.AtlasTexture.GetPixels(Mathf.RoundToInt(srcRect.x), Mathf.RoundToInt(srcRect.y), autoTileset.TileWidth, autoTileset.TileHeight);
tilesetTexture.SetPixels(Mathf.RoundToInt(dstRect.x), Mathf.RoundToInt(dstRect.y), autoTileset.TileWidth, autoTileset.TileHeight, autotileColors);
}
}
tilesetTexture.Apply();
return tilesetTexture;
}
private bool _validateTilesetTextures(AtlasSlot atlasSlot)
{
//+++ old values for 32x32 tiles, now depend on tile size
int _512 = 16 * m_autoTileset.TileWidth;
int _480 = 15 * m_autoTileset.TileWidth;
int _384 = 12 * m_autoTileset.TileWidth;
int _256 = 8 * m_autoTileset.TileWidth;
//---
List <Texture2D> invalidTextures = new List <Texture2D>();
Debug.Log("atlasSlot.SubTilesets.Count " + atlasSlot.SubTilesets.Count);
for (int i = 0; i < atlasSlot.SubTilesets.Count; ++i)
{
SubTilesetConf tilesetConf = atlasSlot.SubTilesets[i];
if (tilesetConf.HasAutotiles)
{
Debug.Log(tilesetConf.SourceTexture.Length);
for (int j = 0; j < tilesetConf.SourceTexture.Length; ++j)
{
if (tilesetConf.SourceTexture[j] != null &&
(
(j == 0) && (tilesetConf.SourceTexture[j].width != _512 || tilesetConf.SourceTexture[j].height != _384) ||
(j == 1) && (tilesetConf.SourceTexture[j].width != _512 || tilesetConf.SourceTexture[j].height != _384) ||
(j == 2) && (tilesetConf.SourceTexture[j].width != _512 || tilesetConf.SourceTexture[j].height != _256) ||
(j == 3) && (tilesetConf.SourceTexture[j].width != _512 || tilesetConf.SourceTexture[j].height != _480) ||
(j == 4) && (tilesetConf.SourceTexture[j].width != _256 || tilesetConf.SourceTexture[j].height != _512)
)
)
{
invalidTextures.Add(tilesetConf.SourceTexture[j]);
tilesetConf.SourceTexture[j] = null;
}
}
}
else
{
if (tilesetConf.SourceTexture[0] != null && (tilesetConf.SourceTexture[0].width != _512 || tilesetConf.SourceTexture[0].height != _512))
{
invalidTextures.Add(tilesetConf.SourceTexture[0]);
tilesetConf.SourceTexture[0] = null;
}
}
}
if (invalidTextures.Count > 0)
{
string wrongTextures = "";
foreach (Texture2D text in invalidTextures)
{
wrongTextures += "\n" + text.name;
}
EditorUtility.DisplayDialog(
"Wrong texture size", "One or more textures have a wrong texture size:" + wrongTextures + "\n" +
"The texture size could be changed by the import settings. If this is the case, use Texture Type: Sprite in the texture import settings."
, "Ok");
}
return(invalidTextures.Count == 0);
}
/// <summary>
/// Fill a list of rects with all rect sources for the thumbnails of the tiles. For normal tiles is the same tile, but autotiles are special.
/// </summary>
/// <param name="_outList"></param>
/// <param name="autoTileset"></param>
/// <param name="tilesetConf"></param>
public static void FillWithTilesetThumbnailSprites( List<Rect> _outList, AutoTileset autoTileset, SubTilesetConf tilesetConf)
{
//+++ old values for 32x32 tiles, now depend on tile size
int _1024 = 32 * autoTileset.TileWidth;
int _768 = 24 * autoTileset.TileWidth;
int _640 = 20 * autoTileset.TileWidth;
int _512 = 16 * autoTileset.TileWidth;
int _384 = 12 * autoTileset.TileWidth;
int _256 = 8 * autoTileset.TileWidth;
//---
Rect sprRect = new Rect(0, 0, autoTileset.TileWidth, autoTileset.TileHeight);
int AtlasPosX = (int)tilesetConf.AtlasRec.x;
int AtlasPosY = (int)tilesetConf.AtlasRec.y;
if (tilesetConf.HasAutotiles)
{
// animated
for (sprRect.y = _384 - autoTileset.TileHeight; sprRect.y >= 0; sprRect.y -= 3 * autoTileset.TileHeight)
{
int tx;
for (tx = 0, sprRect.x = 0; sprRect.x < _512; sprRect.x += 2 * autoTileset.TileWidth, ++tx)
{
if( tx % 4 == 0 || tx % 4 == 3 )
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
}
}
// ground
for (sprRect.y = _768 - autoTileset.TileHeight; sprRect.y >= _384; sprRect.y -= 3 * autoTileset.TileHeight)
{
for (sprRect.x = 0; sprRect.x < _512; sprRect.x += 2 * autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
}
// building
for (sprRect.y = _512 + 3 * autoTileset.TileHeight; sprRect.y >= _512; sprRect.y -= autoTileset.TileHeight)
{
for (sprRect.x = _768; sprRect.x < _768 + 8 * autoTileset.TileWidth; sprRect.x += autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
}
// walls
sprRect.y = (15 - 1) * autoTileset.TileHeight;
for (sprRect.x = _512; sprRect.x < _1024; sprRect.x += 2 * autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
sprRect.y = _640 + 2 * autoTileset.TileHeight;
for (sprRect.x = _768; sprRect.x < _768 + 8 * autoTileset.TileWidth; sprRect.x += autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
sprRect.y = (10 - 1) * autoTileset.TileHeight;
for (sprRect.x = _512; sprRect.x < _1024; sprRect.x += 2 * autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
sprRect.y = _640 + autoTileset.TileHeight;
for (sprRect.x = _768; sprRect.x < _768 + 8 * autoTileset.TileWidth; sprRect.x += autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
sprRect.y = (5 - 1) * autoTileset.TileHeight;
for (sprRect.x = _512; sprRect.x < _1024; sprRect.x += 2 * autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
sprRect.y = _640;
for (sprRect.x = _768; sprRect.x < _768 + 8 * autoTileset.TileWidth; sprRect.x += autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
//--- walls
//Normal
_FillSpritesFromRect(_outList, autoTileset, _512 + AtlasPosX, _512 + AtlasPosY, _256, _512);
}
else
{ // split the tileset to create a column of 8 tiles per row
_FillSpritesFromRect(_outList, autoTileset, AtlasPosX, AtlasPosY, _256, _512);
_FillSpritesFromRect(_outList, autoTileset, AtlasPosX+_256, AtlasPosY, _256, _512);
}
}
/// <summary>
/// Fill a list of rects with all rect sources for the thumbnails of the tiles. For normal tiles is the same tile, but autotiles are special.
/// </summary>
/// <param name="_outList"></param>
/// <param name="autoTileset"></param>
/// <param name="tilesetConf"></param>
public static void FillWithTilesetThumbnailSprites(List <Rect> _outList, AutoTileset autoTileset, SubTilesetConf tilesetConf)
{
//+++ old values for 32x32 tiles, now depend on tile size
int _1024 = 32 * autoTileset.TileWidth;
int _768 = 24 * autoTileset.TileWidth;
int _640 = 20 * autoTileset.TileWidth;
int _512 = 16 * autoTileset.TileWidth;
int _384 = 12 * autoTileset.TileWidth;
int _256 = 8 * autoTileset.TileWidth;
//---
Rect sprRect = new Rect(0, 0, autoTileset.TileWidth, autoTileset.TileHeight);
int AtlasPosX = (int)tilesetConf.AtlasRec.x;
int AtlasPosY = (int)tilesetConf.AtlasRec.y;
if (tilesetConf.HasAutotiles)
{
// animated
for (sprRect.y = _384 - autoTileset.TileHeight; sprRect.y >= 0; sprRect.y -= 3 * autoTileset.TileHeight)
{
int tx;
for (tx = 0, sprRect.x = 0; sprRect.x < _512; sprRect.x += 2 * autoTileset.TileWidth, ++tx)
{
if (tx % 4 == 0 || tx % 4 == 3)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
}
}
// ground
for (sprRect.y = _768 - autoTileset.TileHeight; sprRect.y >= _384; sprRect.y -= 3 * autoTileset.TileHeight)
{
for (sprRect.x = 0; sprRect.x < _512; sprRect.x += 2 * autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
}
// building
for (sprRect.y = _512 + 3 * autoTileset.TileHeight; sprRect.y >= _512; sprRect.y -= autoTileset.TileHeight)
{
for (sprRect.x = _768; sprRect.x < _768 + 8 * autoTileset.TileWidth; sprRect.x += autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
}
// walls
sprRect.y = (15 - 1) * autoTileset.TileHeight;
for (sprRect.x = _512; sprRect.x < _1024; sprRect.x += 2 * autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
sprRect.y = _640 + 2 * autoTileset.TileHeight;
for (sprRect.x = _768; sprRect.x < _768 + 8 * autoTileset.TileWidth; sprRect.x += autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
sprRect.y = (10 - 1) * autoTileset.TileHeight;
for (sprRect.x = _512; sprRect.x < _1024; sprRect.x += 2 * autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
sprRect.y = _640 + autoTileset.TileHeight;
for (sprRect.x = _768; sprRect.x < _768 + 8 * autoTileset.TileWidth; sprRect.x += autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
sprRect.y = (5 - 1) * autoTileset.TileHeight;
for (sprRect.x = _512; sprRect.x < _1024; sprRect.x += 2 * autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
sprRect.y = _640;
for (sprRect.x = _768; sprRect.x < _768 + 8 * autoTileset.TileWidth; sprRect.x += autoTileset.TileWidth)
{
Rect r = sprRect; r.position += tilesetConf.AtlasRec.position;
_outList.Add(r);
}
//--- walls
//Normal
_FillSpritesFromRect(_outList, autoTileset, _512 + AtlasPosX, _512 + AtlasPosY, _256, _512);
}
else
{ // split the tileset to create a column of 8 tiles per row
_FillSpritesFromRect(_outList, autoTileset, AtlasPosX, AtlasPosY, _256, _512);
_FillSpritesFromRect(_outList, autoTileset, AtlasPosX + _256, AtlasPosY, _256, _512);
}
}
void FillData()
{
m_animatedTiles.Clear();
m_animatedWaterfallTiles.Clear();
m_vertices = new Vector3[TileWidth * TileHeight * 4 * 4]; // 4 subtiles x 4 vertex per tile
m_colors = new Color32[TileWidth * TileHeight * 4 * 4];
m_uv = new Vector2[m_vertices.Length];
m_triangles = new int[TileWidth * TileHeight * 4 * 2 * 3]; // 4 subtiles x 2 triangles per tile x 3 vertex per triangle
int vertexIdx = 0;
int triangleIdx = 0;
//TODO: optimize updating only updated tiles inside the chunk
Dictionary <int, AutoTile> tileCache = new Dictionary <int, AutoTile>();
int mapWidth = MyAutoTileMap.MapTileWidth;
int mapHeight = MyAutoTileMap.MapTileHeight;
for (int tileX = 0; tileX < TileWidth; ++tileX)
{
for (int tileY = 0; tileY < TileHeight; ++tileY)
{
int tx = StartTileX + tileX;
int ty = StartTileY + tileY;
if (tx >= mapWidth || ty >= mapHeight)
{
continue;
}
int tileIdx = ty * MyAutoTileMap.MapTileWidth + tx;
AutoTile autoTile;
if (!tileCache.TryGetValue(tileIdx, out autoTile))
{
//Debug.Log(" Cache miss! ");
autoTile = MyAutoTileMap.GetAutoTile(StartTileX + tileX, StartTileY + tileY, MapLayerIdx);
tileCache[tileIdx] = autoTile;
}
if (autoTile.Id >= 0)
{
int subTileXBase = tileX << 1; // <<1 == *2
int subTileYBase = tileY << 1; // <<1 == *2
for (int xf = 0; xf < 2; ++xf)
{
for (int yf = 0; yf < 2; ++yf)
{
int subTileX = subTileXBase + xf;
int subTileY = subTileYBase + yf;
float px0 = subTileX * (MyAutoTileMap.CellSize.x / 2f);
float py0 = -subTileY * (MyAutoTileMap.CellSize.y / 2f);
float px1 = (subTileX + 1) * (MyAutoTileMap.CellSize.x / 2f);
float py1 = -(subTileY + 1) * (MyAutoTileMap.CellSize.y / 2f);
m_vertices[vertexIdx + 0] = new Vector3(px0, py0, 0);
m_vertices[vertexIdx + 1] = new Vector3(px0, py1, 0);
m_vertices[vertexIdx + 2] = new Vector3(px1, py1, 0);
m_vertices[vertexIdx + 3] = new Vector3(px1, py0, 0);
m_colors[vertexIdx + 0] = new Color32(255, 255, 255, 255);
m_colors[vertexIdx + 1] = new Color32(255, 255, 255, 255);
m_colors[vertexIdx + 2] = new Color32(255, 255, 255, 255);
m_colors[vertexIdx + 3] = new Color32(255, 255, 255, 255);
m_triangles[triangleIdx + 0] = vertexIdx + 2;
m_triangles[triangleIdx + 1] = vertexIdx + 1;
m_triangles[triangleIdx + 2] = vertexIdx + 0;
m_triangles[triangleIdx + 3] = vertexIdx + 0;
m_triangles[triangleIdx + 4] = vertexIdx + 3;
m_triangles[triangleIdx + 5] = vertexIdx + 2;
float u0, u1, v0, v1;
if (autoTile.Type == eTileType.OBJECTS || autoTile.Type == eTileType.NORMAL)
{
int spriteIdx = autoTile.TilePartsIdx[0];
Rect sprTileRect = MyAutoTileMap.Tileset.AutoTileRects[spriteIdx];
u0 = (((subTileX % 2) * sprTileRect.width / 2) + sprTileRect.x) / MyAutoTileMap.Tileset.AtlasTexture.width;
u1 = (((subTileX % 2) * sprTileRect.width / 2) + sprTileRect.x + sprTileRect.width / 2) / MyAutoTileMap.Tileset.AtlasTexture.width;
v0 = (((1 - subTileY % 2) * sprTileRect.height / 2) + sprTileRect.y + sprTileRect.height / 2) / MyAutoTileMap.Tileset.AtlasTexture.height;
v1 = (((1 - subTileY % 2) * sprTileRect.height / 2) + sprTileRect.y) / MyAutoTileMap.Tileset.AtlasTexture.height;
}
else
{
int tilePartIdx = (subTileY % 2) * 2 + (subTileX % 2);
int spriteIdx = autoTile.TilePartsIdx[tilePartIdx];
Rect sprTileRect = MyAutoTileMap.Tileset.AutoTileRects[spriteIdx];
u0 = sprTileRect.x / MyAutoTileMap.Tileset.AtlasTexture.width;
u1 = (sprTileRect.x + sprTileRect.width) / MyAutoTileMap.Tileset.AtlasTexture.width;
v0 = (sprTileRect.y + sprTileRect.height) / MyAutoTileMap.Tileset.AtlasTexture.height;
v1 = sprTileRect.y / MyAutoTileMap.Tileset.AtlasTexture.height;
if (MyAutoTileMap.Tileset.IsAutoTileAnimated(autoTile.Id))
{
m_animatedTiles.Add(new AnimTileData()
{
VertexIdx = vertexIdx, U0 = u0, U1 = u1
});
}
else if (MyAutoTileMap.Tileset.IsAutoTileAnimatedWaterfall(autoTile.Id))
{
SubTilesetConf tilesetConf = MyAutoTileMap.Tileset.SubTilesets[autoTile.Id / AutoTileset.k_TilesPerSubTileset];
int spriteIdxRelToSubTileset = spriteIdx - tilesetConf.TilePartOffset[0];
int subTileRow = (spriteIdxRelToSubTileset / 32); //32 = number of subtiles in a row;
subTileRow %= 6; // make it relative to this autotile
subTileRow -= 2; // remove top tiles
m_animatedWaterfallTiles.Add(new AnimTileData()
{
VertexIdx = vertexIdx, V0 = v0, V1 = v1, SubTileRow = subTileRow
});
}
}
m_uv[vertexIdx + 0] = new Vector3(u0, v0, 0);
m_uv[vertexIdx + 1] = new Vector3(u0, v1, 0);
m_uv[vertexIdx + 2] = new Vector3(u1, v1, 0);
m_uv[vertexIdx + 3] = new Vector3(u1, v0, 0);
// increment vectex and triangle idx
vertexIdx += 4;
triangleIdx += 6;
}
}
}
}
}
// resize arrays
System.Array.Resize(ref m_vertices, vertexIdx);
System.Array.Resize(ref m_colors, vertexIdx);
System.Array.Resize(ref m_uv, vertexIdx);
System.Array.Resize(ref m_triangles, triangleIdx);
}
