private Quaternion tileRotation(LBDTile tile)
{
switch (tile.TileDirection)
{
case LBDTile.TileDirections.Deg90:
{
return(Quaternion.AngleAxis(90, Vector3.up));
}
case LBDTile.TileDirections.Deg180:
{
return(Quaternion.AngleAxis(180, Vector3.up));
}
case LBDTile.TileDirections.Deg270:
{
return(Quaternion.AngleAxis(270, Vector3.up));
}
default:
{
return(Quaternion.identity);
}
}
}
public static List <IRenderable> CreateLBDTileMesh(LBDTile tile,
LBDTile[] extraTiles,
int x,
int y,
TMD tilesTmd,
Shader shader,
ITexture2D vram,
bool headless)
{
List <IRenderable> returnMeshList = new List <IRenderable>();
returnMeshList.Add(createSingleLBDTileMesh(tile, x, y, tilesTmd, shader, vram, headless));
LBDTile currentTile = tile;
int i = 0;
while (currentTile.ExtraTileIndex >= 0 && i <= 1)
{
LBDTile extraTile = extraTiles[currentTile.ExtraTileIndex];
returnMeshList.Add(createSingleLBDTileMesh(extraTile, x, y, tilesTmd, shader, vram, headless));
currentTile = extraTile;
i++;
}
return(returnMeshList);
}
// create an LBD tile GameObject
private static GameObject createLBDTile(LBDTile tile,
LBDTile[] extraTiles,
int x,
int y,
TMD tilesTmd,
List <CombineInstance> meshesCreated)
{
// create the GameObject for the base tile
GameObject lbdTile = createSingleLBDTile(tile, x, y, tilesTmd, meshesCreated);
// now see if it has any extra tiles, and create those
LBDTile curTile = tile;
int i = 0;
while (curTile.ExtraTileIndex >= 0 && i <= 1)
{
LBDTile extraTile = extraTiles[curTile.ExtraTileIndex];
GameObject extraTileObj = createSingleLBDTile(extraTile, x, y, tilesTmd, meshesCreated);
extraTileObj.transform.SetParent(lbdTile.transform, true); // parent them to original tile
curTile = extraTile;
i++;
}
return(lbdTile);
}
private FastMesh createTileMesh(LBDTile tile, TMD tilesTmd, Dictionary <TMDObject, FastMesh> tileCache)
{
TMDObject tileObj = tilesTmd.ObjectTable[tile.TileType];
if (tileCache.ContainsKey(tileObj))
{
return(tileCache[tileObj]);
}
Mesh m = LibLSDUnity.MeshFromTMDObject(tileObj);
FastMesh fm = new FastMesh(m, new[] { LBDDiffuse, LBDAlpha });
tileCache[tileObj] = fm;
return(fm);
}
public LBDTileTreeNode(string text,
IRenderable tileMesh,
LBDTile tile,
List <IRenderable> meshes) : base(text, meshes)
{
_tileMesh = tileMesh;
var footstepSoundAndCollision = Convert.ToString(tile.FootstepSoundAndCollision, 2);
var unknown = tile.UnknownFlag == 1 ? "true" : "false";
_tooltip = () =>
{
ImGui.Text($"{footstepSoundAndCollision} - footstep/collision");
ImGui.Text($"{unknown} - unknown");
ImGui.Text($"{tile.UnknownFlag}");
};
}
private static IRenderable createSingleLBDTileMesh(LBDTile tile,
int x,
int y,
TMD tilesTmd,
Shader shader,
ITexture2D vram,
bool headless)
{
TMDObject tileObj = tilesTmd.ObjectTable[tile.TileType];
IRenderable tileMesh = MeshFromTMDObject(tileObj, shader, headless);
switch (tile.TileDirection)
{
case LBDTile.TileDirections.Deg90:
{
tileMesh.Transform.Rotation =
Quaternion.FromAxisAngle(Vector3.UnitY, MathHelper.DegreesToRadians(90));
break;
}
case LBDTile.TileDirections.Deg180:
{
tileMesh.Transform.Rotation =
Quaternion.FromAxisAngle(Vector3.UnitY, MathHelper.DegreesToRadians(180));
break;
}
case LBDTile.TileDirections.Deg270:
{
tileMesh.Transform.Rotation =
Quaternion.FromAxisAngle(Vector3.UnitY, MathHelper.DegreesToRadians(270));
break;
}
}
tileMesh.Transform.Position = new Vector3(x, tile.TileHeight, y);
tileMesh.Textures.Add(vram);
return(tileMesh);
}
private GameObject createLBDTileMap(LBD lbd, Vector3 posOffset, Dictionary <TMDObject, FastMesh> tileCache)
{
List <CombineInstance> colliderMeshes = new List <CombineInstance>();
int tileNo = 0;
for (int i = 0; i < lbd.TileLayout.Length; i++)
{
int x = tileNo % lbd.Header.TileWidth;
int y = tileNo / lbd.Header.TileWidth;
LBDTile tile = lbd.TileLayout[x, y];
// create an LBD tile if we should draw it
if (tile.DrawTile)
{
FastMesh mesh = createTileMesh(tile, lbd.Tiles, tileCache);
var matrix = mesh.AddInstance(new Vector3(x, -tile.TileHeight, y) + posOffset, tileRotation(tile));
colliderMeshes.Add(new CombineInstance
{
mesh = mesh.Mesh,
transform = matrix,
subMeshIndex = 0
});
if (mesh.Mesh.subMeshCount > 1)
{
colliderMeshes.Add(new CombineInstance
{
mesh = mesh.Mesh,
transform = matrix,
subMeshIndex = 1
});
}
// now do extra tiles
LBDTile curTile = tile;
int j = 0;
while (curTile.ExtraTileIndex >= 0 && j <= 1)
{
LBDTile extraTile = lbd.ExtraTiles[curTile.ExtraTileIndex];
FastMesh extraTileMesh = createTileMesh(extraTile, lbd.Tiles, tileCache);
var extraMatrix =
extraTileMesh.AddInstance(new Vector3(x, -extraTile.TileHeight, y) + posOffset,
tileRotation(extraTile));
colliderMeshes.Add(new CombineInstance
{
mesh = extraTileMesh.Mesh,
transform = extraMatrix,
subMeshIndex = 0
});
if (extraTileMesh.Mesh.subMeshCount > 1)
{
colliderMeshes.Add(new CombineInstance
{
mesh = extraTileMesh.Mesh,
transform = extraMatrix,
subMeshIndex = 1
});
}
curTile = extraTile;
j++;
}
}
tileNo++;
}
return(createLBDCollider(colliderMeshes, posOffset));
}
// create a single LBD tile GameObject (not including extra tiles)
private GameObject createSingleLBDTile(LBDTile tile, int x, int y, TMD tilesTmd,
List <CombineInstance> meshesCreated, Dictionary <TMDObject, Mesh> cache)
{
// rotate the tile based on its direction
Quaternion tileRot = Quaternion.identity;
switch (tile.TileDirection)
{
case LBDTile.TileDirections.Deg90:
{
tileRot = Quaternion.AngleAxis(90, Vector3.up);
break;
}
case LBDTile.TileDirections.Deg180:
{
tileRot = Quaternion.AngleAxis(180, Vector3.up);
break;
}
case LBDTile.TileDirections.Deg270:
{
tileRot = Quaternion.AngleAxis(270, Vector3.up);
break;
}
}
// create the GameObject and add/setup necessary components
GameObject lbdTile = LBDTilePool.Summon(new Vector3(x, -tile.TileHeight, y), tileRot);
MeshFilter mf = lbdTile.GetComponent <MeshFilter>();
MeshRenderer mr = lbdTile.GetComponent <MeshRenderer>();
TMDObject tileObj = tilesTmd.ObjectTable[tile.TileType];
Mesh tileMesh;
if (cache.ContainsKey(tileObj))
{
tileMesh = cache[tileObj];
}
else
{
tileMesh = LibLSDUnity.MeshFromTMDObject(tileObj);
cache[tileObj] = tileMesh;
}
mf.sharedMesh = tileMesh;
// the renderer needs to use virtual PSX Vram as its materials
mr.sharedMaterials = new[] { LBDDiffuse, LBDAlpha };
// set the tile's height
lbdTile.transform.position = new Vector3(x, -tile.TileHeight, y);
// make a CombineInstance for combining all tiles into one mesh later on
var localToWorldMatrix = lbdTile.transform.localToWorldMatrix;
CombineInstance combine = new CombineInstance()
{
mesh = tileMesh,
transform = localToWorldMatrix,
subMeshIndex = 0
};
meshesCreated.Add(combine);
// if tile has transparent part, do the same for the transparent mesh
if (tileMesh.subMeshCount > 1)
{
CombineInstance combineTrans = new CombineInstance()
{
mesh = tileMesh,
transform = localToWorldMatrix,
subMeshIndex = 1
};
meshesCreated.Add(combineTrans);
}
return(lbdTile);
}
// create a single LBD tile GameObject (not including extra tiles)
private static GameObject createSingleLBDTile(LBDTile tile, int x, int y, TMD tilesTmd,
List <CombineInstance> meshesCreated)
{
// create the GameObject and add/setup necessary components
GameObject lbdTile = new GameObject($"Tile {tile.TileType}");
MeshFilter mf = lbdTile.AddComponent <MeshFilter>();
MeshRenderer mr = lbdTile.AddComponent <MeshRenderer>();
lbdTile.AddComponent <CullMeshOnDistance>();
lbdTile.AddComponent <MeshFog>();
TMDObject tileObj = tilesTmd.ObjectTable[tile.TileType];
Mesh tileMesh = MeshFromTMDObject(tileObj);
mf.mesh = tileMesh;
// the renderer needs to use virtual PSX Vram as its materials
mr.sharedMaterials = new[] { PsxVram.VramMaterial, PsxVram.VramAlphaBlendMaterial };
// rotate the tile based on its direction
switch (tile.TileDirection)
{
case LBDTile.TileDirections.Deg90:
{
lbdTile.transform.Rotate(Vector3.up, 90);
break;
}
case LBDTile.TileDirections.Deg180:
{
lbdTile.transform.Rotate(Vector3.up, 180);
break;
}
case LBDTile.TileDirections.Deg270:
{
lbdTile.transform.Rotate(Vector3.up, 270);
break;
}
}
// set the tile's height
lbdTile.transform.position = new Vector3(x, -tile.TileHeight, y);
// make a CombineInstance for combining all tiles into one mesh later on
var localToWorldMatrix = lbdTile.transform.localToWorldMatrix;
CombineInstance combine = new CombineInstance()
{
mesh = tileMesh,
transform = localToWorldMatrix,
subMeshIndex = 0
};
meshesCreated.Add(combine);
// if tile has transparent part, do the same for the transparent mesh
if (tileMesh.subMeshCount > 1)
{
CombineInstance combineTrans = new CombineInstance()
{
mesh = tileMesh,
transform = localToWorldMatrix,
subMeshIndex = 1
};
meshesCreated.Add(combineTrans);
}
return(lbdTile);
}
private MeshListTreeNode createLBDNode(string name, LBDDocument lbdDoc)
{
MeshListTreeNode rootNode = new MeshListTreeNode(name, lbdDoc.TileLayout, contextMenu: new ContextMenu(
new Dictionary <string, Action>
{
{
"Export as LBD",
() =>
{
_exportController.OpenDialog(
filePath => { _exportController.ExportOriginal(lbdDoc.Document, filePath); }, ".lbd");
}
},
{
"Export as OBJ",
() =>
{
_exportController.OpenDialog(
filePath => { _exportController.ExportOBJ(lbdDoc.TileLayout, filePath); }, ".obj");
}
},
{
"Export as PLY",
() =>
{
_exportController.OpenDialog(
filePath => { _exportController.ExportPLY(lbdDoc.TileLayout, filePath); }, ".ply");
}
}
}));
TreeNode tilesNode = createTMDNode("Tiles", lbdDoc.TilesTMD);
rootNode.AddNode(tilesNode);
TreeNode tileInfoNode = new TreeNode("Tile info");
rootNode.AddNode(tileInfoNode);
int tileNo = 0;
int i = 0;
foreach (LBDTile tile in lbdDoc.Document.TileLayout)
{
if (tile.DrawTile)
{
int x = tileNo / lbdDoc.Document.Header.TileWidth;
int y = tileNo % lbdDoc.Document.Header.TileWidth;
var tileMesh = lbdDoc.TileLayout[i];
LBDTileTreeNode tileNode =
new LBDTileTreeNode($"({x}, {y})", tileMesh, tile, lbdDoc.TileLayout);
tileInfoNode.AddNode(tileNode);
LBDTile currentTile = tile;
int j = 0;
while (currentTile.ExtraTileIndex >= 0 && j <= 1)
{
LBDTile extraTile = lbdDoc.Document.ExtraTiles[currentTile.ExtraTileIndex];
tileMesh = lbdDoc.TileLayout[i + j + 1];
tileNode =
new LBDTileTreeNode($"({x}, {y}) extra", tileMesh, tile, lbdDoc.TileLayout);
tileInfoNode.AddNode(tileNode);
currentTile = extraTile;
j++;
}
i += j + 1;
}
tileNo++;
}
if (lbdDoc.Entities != null)
{
TreeNode objectsNode = createMMLNode("Entities", lbdDoc.Entities, lbdDoc.Document.MML.Value);
rootNode.AddNode(objectsNode);
}
return(rootNode);
}
