public void LoadTIXIntoVRAM(string tixPath)
{
Logger.Log()(LogLevel.INFO, $"Loading TIX from {tixPath} into virtual VRAM");
TIX tix;
using (BinaryReader br = new BinaryReader(File.Open(tixPath, FileMode.Open)))
{
tix = new TIX(br);
}
Logger.Log()(LogLevel.INFO, $"Successfully loaded TIX");
foreach (var chunk in tix.Chunks)
{
foreach (var tim in chunk.TIMs)
{
var image = LibLSDUtil.GetImageDataFromTIM(tim);
int actualXPos = (tim.PixelData.XPosition - 320) * 2;
int actualYPos = 512 - tim.PixelData.YPosition - image.height;
VRAMTexture.SubImage(image.data, actualXPos, actualYPos, image.width, image.height);
}
}
VRAMLoaded = true;
}
public void UseTIX(TIX tix)
{
var tex = LibLSDUnity.GetTextureFromTIX(tix);
LBDDiffuse.SetTexture(_mainTex, tex);
LBDAlpha.SetTexture(_mainTex, tex);
}
/// <summary>
/// Get a Unity Texture2D from a loaded TIX image archive.
/// </summary>
/// <param name="tix">The TIX file loaded.</param>
/// <returns>A Texture2D containing all images inside the TIX archive laid out as if in VRAM.</returns>
public static Texture2D GetTextureFromTIX(TIX tix)
{
// create a texture 2D with the required format
Texture2D tex = new Texture2D(PsxVram.VRAM_WIDTH, PsxVram.VRAM_HEIGHT, TextureFormat.ARGB32, false)
{
wrapMode = TextureWrapMode.Clamp, filterMode = FilterMode.Point
};
// fill the texture with a white colour
Color[] fill = new Color[PsxVram.VRAM_WIDTH * PsxVram.VRAM_HEIGHT];
for (int i = 0; i < fill.Length; i++)
{
fill[i] = new Color(1, 1, 1, 1);
}
tex.SetPixels(fill);
tex.Apply();
// for each image within the archive, load it and paint it on the 'canvas' we created above
foreach (var chunk in tix.Chunks)
{
foreach (var tim in chunk.TIMs)
{
var image = GetImageDataFromTIM(tim);
int actualXPos = (tim.PixelData.XPosition - 320) * 2;
int actualYPos = 512 - tim.PixelData.YPosition - image.Height;
tex.SetPixels(actualXPos, actualYPos, image.Width, image.Height, TimDataToColors(image));
tex.Apply();
}
}
return(tex);
}
public static ITexture2D TIXToTexture2D(TIX tix, bool headless, bool flip = true)
{
float[] texData = new float[VRAM_WIDTH * VRAM_HEIGHT * 4];
ITexture2D tex = headless
? (ITexture2D) new HeadlessTexture2D(VRAM_WIDTH, VRAM_HEIGHT, texData)
: (ITexture2D) new Texture2D(VRAM_WIDTH, VRAM_HEIGHT, texData);
TIXToTexture2D(tix, ref tex, flip);
return(tex);
}
public TIXDocument CreateDocument(TIX tix)
{
List <TIMDocument> tims = new List <TIMDocument>();
foreach (var tim in tix.AllTIMs)
{
tims.Add(_timController.CreateDocument(tim));
}
return(new TIXDocument(tix, tims));
}
public void Load(string path, int span)
{
TIX tix;
using (BinaryReader br = new BinaryReader(File.Open(path, FileMode.Open)))
{
tix = new TIX(br);
}
Resource <TIX> resource = new Resource <TIX>(tix, span);
ResourceManager.RegisterResource(path, resource);
}
/// <summary>
/// Export the TIM files in a TIX to common image formats.
/// </summary>
/// <param name="tix">The TIX file.</param>
/// <param name="filePath">The file path to export to.</param>
/// <param name="format">The image format to export to.</param>
public void ExportImages(TIX tix, string filePath, ImageFormat format)
{
Logger.Log()(LogLevel.INFO, $"Exporting images ({format}) in TIX to: {filePath}");
var allTims = tix.AllTIMs;
for (int i = 0; i < allTims.Count; i++)
{
var fileName = Path.GetFileNameWithoutExtension(filePath);
var ext = Path.GetExtension(filePath);
var dir = Path.GetDirectoryName(filePath);
ExportImage(allTims[i], Path.Combine(dir, $"{fileName}-{i}{ext}"), format);
}
}
public static TIX LoadTIX(string filePath)
{
Log.Information($"Loading TIX from: {filePath}");
TIX tix;
using (BinaryReader br = new BinaryReader(File.Open(filePath, FileMode.Open)))
{
tix = new TIX(br);
}
Log.Information("Successfully loaded TIX");
return(tix);
}
public static void TIXToTexture2D(TIX tix, ref ITexture2D tex, bool flip = true)
{
foreach (var chunk in tix.Chunks)
{
foreach (var tim in chunk.TIMs)
{
var image = GetImageDataFromTIM(tim, flip: flip);
int actualXPos = (tim.PixelData.XPosition - 320) * 2;
int actualYPos = 512 - tim.PixelData.YPosition - image.height;
Log.Debug(
$"[{tim.PixelData.XPosition}, {tim.PixelData.YPosition}] -> ({actualXPos}, {actualYPos})");
tex.SubImage(image.data, actualXPos, actualYPos, image.width, image.height);
}
}
}
public void LoadTIX(string tixPath)
{
Logger.Log()(LogLevel.INFO, $"Loading TIX from: {tixPath}");
TIX tix;
using (BinaryReader br = new BinaryReader(File.Open(tixPath, FileMode.Open)))
{
tix = new TIX(br);
}
Logger.Log()(LogLevel.INFO, "Successfully loaded TIX");
TIXDocument document = CreateDocument(tix);
_treeController.PopulateTreeWithDocument(document, Path.GetFileName(tixPath));
}
private void loadLBD()
{
var start = DateTime.Now;
Profiler.BeginSample("LBD");
_tix = ResourceManager.Load <TIX>(IOUtil.PathCombine(Application.streamingAssetsPath, TIXFile));
PsxVram.LoadVramTix(_tix);
// get an array of all of the LBD files in the given directory
// TODO: error checking for LBD path
string[] lbdFiles = Directory.GetFiles(IOUtil.PathCombine(Application.streamingAssetsPath, LBDFolder),
"*.LBD", SearchOption.AllDirectories);
_cache.Clear();
int i = 0;
foreach (var file in lbdFiles)
{
// load the LBD and create GameObjects for its tiles
var lbd = ResourceManager.Load <LBD>(file);
GameObject lbdObj = _lbdReader.CreateLBDTileMap(lbd, _cache);
Debug.Log($"Cache entries: {_cache.Count}");
// position the LBD 'slab' based on its tiling mode
if (Mode == LBDTiling.Regular)
{
int xPos = i % LBDWidth;
int yPos = i / LBDWidth;
int xMod = 0;
if (yPos % 2 == 1)
{
xMod = 10;
}
lbdObj.transform.position = new Vector3((xPos * 20) - xMod, 0, yPos * 20);
i++;
}
}
Profiler.EndSample();
_loaded = true;
var end = DateTime.Now;
}
public void LoadTIXIntoVRAM(string tixPath)
{
Log.Information($"Loading TIX from {tixPath} into virtual VRAM");
using (BinaryReader br = new BinaryReader(File.Open(tixPath, FileMode.Open)))
{
Tix = new TIX(br);
}
Log.Information("Successfully loaded TIX");
if (VRAM != null)
{
disposeOldVRAM();
}
VRAM = LibLSDUtil.TIXToTexture2D(Tix, headless: true, flip: false);
VRAMLoaded = true;
}
/// <summary>
/// Export the TIM files in a TIX to common image formats.
/// </summary>
/// <param name="tix">The TIX file.</param>
/// <param name="filePath">The file path to export to.</param>
/// <param name="separate">Whether or not to separate images in the output.</param>
/// <param name="format">The image format to export to.</param>
public void ExportImages(TIX tix, string filePath, bool separate, ImageFormat format)
{
if (separate)
{
Log.Information($"Exporting images ({format}) in TIX to: {filePath}");
var allTims = tix.AllTIMs;
for (int i = 0; i < allTims.Count; i++)
{
var fileName = Path.GetFileNameWithoutExtension(filePath);
var ext = Path.GetExtension(filePath);
var dir = Path.GetDirectoryName(filePath);
ExportImage(allTims[i], 0, Path.Combine(dir, $"{fileName}-{i}{ext}"), format);
}
}
else
{
ITexture2D tixTex = LibLSDUtil.TIXToTexture2D(tix, headless: true, flip: false);
ExportTexture(tixTex, filePath, format);
}
}
/// <summary>
/// Load a TIX into the virtual VRAM. 'Paints' textures within the TIX file to the virtual VRAM.
/// </summary>
/// <param name="tix">The TIX file to load into VRAM.</param>
public static void LoadVramTix(TIX tix)
{
VramTexture = LibLSDUnity.GetTextureFromTIX(tix);
VramMaterial.SetTexture(_mainTex, VramTexture);
VramAlphaBlendMaterial.SetTexture(_mainTex, VramTexture);
}
public TIXTexture2D(TIX tix)
{
Tix = tix;
Texture = LibLSDUnity.GetTextureFromTIX(tix);
}
