public static GameFont HiResFromGameData()
{
using (DisposableStack disposables = new DisposableStack(2))
{
GameImage firstImage, secondImage;
ArchiveDirectoryEntry mainDirectory = Archives.GetEntry <ArchiveDirectoryEntry>(MainPath);
ArchiveDirectoryEntry menuDirectory = Archives.GetEntry <ArchiveDirectoryEntry>(MenuPath);
ArchiveDirectoryEntry hiresDirectory = menuDirectory.GetChildEntry <ArchiveDirectoryEntry>(HiResDirectoryName);
ArchiveFileEntry tdwEntry = mainDirectory.GetChildEntry <ArchiveFileEntry>(HiResCharactersWidthsFileName);
ArchiveFileEntry image01 = hiresDirectory.GetChildEntry <ArchiveFileEntry>(HiResFontImage1FileName);
ArchiveFileEntry image02 = hiresDirectory.GetChildEntry <ArchiveFileEntry>(HiResFontImage2FileName);
byte[] widths;
using (TdwFileReader tdwReader = new TdwFileReader(tdwEntry.OpenReadableContentStream()))
widths = tdwReader.Table;
using (TexFileReader texReader = new TexFileReader(image01.OpenReadableContentStream()))
{
firstImage = GameImageReader.FromTex(texReader);
disposables.Add(firstImage.Layer);
}
using (TexFileReader texReader = new TexFileReader(image02.OpenReadableContentStream()))
secondImage = disposables.Add(GameImageReader.FromTex(texReader));
int x = firstImage.X;
int y = firstImage.Y;
GLTexture palettes = firstImage.Palettes;
GLTexture layer = GLTextureFactory.HorizontalJoin(firstImage.Layer, secondImage.Layer);
GameImage image = new GameImage(x, y, layer, palettes);
return(new GameFont(image, widths));
}
}
public static Texture2D FromEmbeddedImage([NotNull] this GLTextureFactory fact, TextureConfig cfg, string name) {
var bmp = LoadFromRes(name);
// update the name to not have the extension.
name = Path.GetFileNameWithoutExtension(name);
var rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
var bitmapData = bmp.LockBits(rect, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
return fact.Create2D(name, cfg, bmp.Width, bmp.Height, bitmapData.Scan0);
}
public static GLTexture LoadDisabledCursorImage()
{
using (Stream input = Assembly.GetExecutingAssembly().GetManifestResourceStream(DisabledCursor))
using (Bitmap bitmap = new Bitmap(input))
{
return(GLTextureFactory.FromBitmap(bitmap, bitmap.Width, bitmap.Height, bitmap.PixelFormat));
}
}
public static GameImage FromTex(TexFileReader reader)
{
const short x = 0;
const short y = 0;
using (DisposableStack insurance = new DisposableStack(2))
{
GLTexture layer = insurance.Add(reader.ReadImage());
GLTexture palettes = insurance.Add(GLTextureFactory.FromBitmapPalettes(reader.Palettes));
GameImage result = new GameImage(x, y, layer, palettes);
insurance.Clear();
return(result);
}
}
private void ReadTextureFromTexFiles(string[] files)
{
GLTexture[] textures = new GLTexture[2];
using (DisposableStack disposables = new DisposableStack(2))
{
for (int i = 0; i < 2; i++)
{
using (FileStream input = File.OpenRead(files[i]))
using (TexFileReader texReader = new TexFileReader(input))
textures[i] = disposables.Add(texReader.ReadImage());
}
_texture = GLTextureFactory.HorizontalJoin(textures[0], textures[1]);
_ownTexture = true;
}
}
public static GameImage FromTim(TimFileReader reader)
{
using (DisposableStack insurance = new DisposableStack(3))
{
TimImage timImage = insurance.Add(reader.ReadImage());
short x = timImage.ImageHeader.X;
short y = timImage.ImageHeader.Y;
GLTexture layer = timImage.Layer;
GLTexture palettes = insurance.Add(GLTextureFactory.FromBitmapPalettes(reader.Palettes == null ? null : reader.Palettes.Palettes));
GameImage result = new GameImage(x, y, layer, palettes);
insurance.Clear();
return(result);
}
}
public static void HiResToGameData(GameFont gameFont)
{
using (DisposableStack disposables = new DisposableStack(2))
{
GLTexture leftTexture;
GLTexture rightTexture;
GLTextureFactory.HorizontalSplit(gameFont.CharactersImage.Layer, out leftTexture, out rightTexture);
disposables.Add(leftTexture);
disposables.Add(rightTexture);
ArchiveDirectoryEntry mainDirectory = Archives.GetEntry <ArchiveDirectoryEntry>(GameFontReader.MainPath);
ArchiveDirectoryEntry menuDirectory = Archives.GetEntry <ArchiveDirectoryEntry>(GameFontReader.MenuPath);
ArchiveDirectoryEntry hiresDirectory = menuDirectory.GetChildEntry <ArchiveDirectoryEntry>(GameFontReader.HiResDirectoryName);
ArchiveFileEntry tdwEntry = mainDirectory.GetChildEntry <ArchiveFileEntry>(GameFontReader.HiResCharactersWidthsFileName);
ArchiveFileEntry image01 = hiresDirectory.GetChildEntry <ArchiveFileEntry>(GameFontReader.HiResFontImage1FileName);
ArchiveFileEntry image02 = hiresDirectory.GetChildEntry <ArchiveFileEntry>(GameFontReader.HiResFontImage2FileName);
using (Stream output = tdwEntry.OpenWritableCapacityStream())
using (TdwFileWriter tdwWriter = new TdwFileWriter(output))
{
tdwWriter.WriteFontCharactersWidths(gameFont.CharactersWidths);
tdwEntry.UpdateMetrics((int)output.Position, tdwEntry.ContentOffset, Compression.None);
}
using (Stream output = image01.OpenWritableCapacityStream())
using (TexFileWriter texWriter = new TexFileWriter(output))
{
texWriter.WriteImage(leftTexture, gameFont.CharactersImage.Palettes);
image01.UpdateMetrics((int)output.Position, image01.ContentOffset, Compression.None);
}
using (Stream output = image02.OpenWritableCapacityStream())
using (TexFileWriter texWriter = new TexFileWriter(output))
{
texWriter.WriteImage(rightTexture, gameFont.CharactersImage.Palettes);
image02.UpdateMetrics((int)output.Position, image02.ContentOffset, Compression.None);
}
Archives.GetInfo(ArchiveName.Main).Update();
Archives.GetInfo(ArchiveName.Menu).Update();
}
}
private static GLTexture ReadLayer(string dirPath, string generalName)
{
string[] files = Directory.GetFiles(dirPath, generalName + ".???");
if (files.Length == 0)
{
return(null);
}
foreach (string file in files)
{
switch ((Path.GetExtension(file) ?? String.Empty).ToLower())
{
case ".png":
case ".gif":
return(GLTextureFactory.FromImageFile(file));
}
}
return(null);
}
private GLTexture Read()
{
switch (_header.BytesPerPixel)
{
case 0:
case 1:
return(GLTextureFactory.FromStream(_input, _imageHeader.Width, _imageHeader.Height, PixelFormat.Format8bppIndexed));
case 2:
return(GLTextureFactory.FromStream(_input, _imageHeader.Width, _imageHeader.Height, PixelFormat.Format16bppArgb1555));
case 3:
return(GLTextureFactory.FromStream(_input, _imageHeader.Width, _imageHeader.Height, PixelFormat.Format24bppRgb));
case 4:
return(GLTextureFactory.FromStream(_input, _imageHeader.Width, _imageHeader.Height, PixelFormat.Format32bppArgb));
default:
throw new NotSupportedException();
}
}
public static DrawingContext CreateOpenGL(int width, int height, bool test = false)
{
var host = test ? (IGraphicsHost) new GLTestGraphicsHost(width, height) : new GLGraphicsHost(width, height);
var textureFactory = new GLTextureFactory(TextureLoader);
var fontFactory = new GLFontTextureFactory(FontLoader);
var modelFactory = new GLModelFactory(ModelLoader);
return(new DrawingContext
{
Host = host,
TexturePreloader = textureFactory,
FontPreloader = fontFactory,
ModelPreloader = modelFactory,
SpriteRenderer = new GLSpriteRenderer(textureFactory),
TextSpriteRenderer = new GLTextSpriteRenderer(fontFactory),
ModelRenderer = new GLModelRenderer(),
});
}
private GLTexture ReadIndexedImage()
{
int size = Header.ImageWidth * Header.ImageHeight * Header.BytesPerPixel;
return(GLTextureFactory.FromStream(IOStream, Header.ImageWidth, Header.ImageHeight, PixelFormat.Format8bppIndexed));
}
private void ReadTextureFromGifFile(string file)
{
_texture = GLTextureFactory.FromImageFile(file);
_ownTexture = true;
}
private static GLTexture ReadPalettes(string dirPath, string generalName)
{
return(GLTextureFactory.FromActPalleteFiles(dirPath, generalName));
}
public static Texture2D FromBitmap([NotNull] this GLTextureFactory fact, string name, TextureConfig cfg, Bitmap bmp) {
var rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
var bitmapData = bmp.LockBits(rect, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
return fact.Create2D(name, cfg, bmp.Width, bmp.Height, bitmapData.Scan0);
}
public GLTexture TryReadData(Stream input)
{
return(GLTextureFactory.FromStream(input, ImageWidth, ImageHeight, PixelFormat.Format8bppIndexed));
}
private GLTexture ReadTexture(Stream input, PixelFormat format)
{
return(GLTextureFactory.FromStream(input, _header.ImageWidth, _header.ImageHeight, format));
}
