public static McaChunk ReadChunk(byte[] buffer, int dx, int dz)
{
//from mca file header
int i = 4 * (dx + dz * 32);
int offset = (buffer [i] << 16) | (buffer [i + 1] << 8) | (buffer [i + 2]);
int sectors = buffer [i + 3];
if (offset == 0 && sectors == 0)
return null;
Console.WriteLine("Read Chunk " + dx + "," + dz + " @ " + offset + ":" + sectors);
if (offset == 0 || sectors == 0)
throw new InvalidDataException("zero offset/sector");
offset = offset << 12; //4096 = 2**12
int length = EndianBitConverter.Big.ToInt32(buffer, offset); //byte length
if (((length + 5 - 1) >> 12) + 1 != sectors)
throw new InvalidDataException("Body length is larger than the sectors, " + length + " > " + (sectors * 4096));
if (buffer [offset + 4] != 2)
throw new NotImplementedException("Only support zlib compression");
McaChunk mc = new McaChunk(dx, dz);
MemoryStream ms = new MemoryStream(buffer, offset + 5, length);
using (ZlibStream compressed = new ZlibStream(ms, CompressionMode.Decompress))
{
EndianBinaryReader r = new EndianBinaryReader(EndianBitConverter.Big, compressed);
mc.Tag = Tag.ReadTag(r);
}
return mc;
}
public void Load(MemoryStream memory)
{
var reader = new EndianBinaryReader(EndianBitConverter.Big, memory);
switch (Format)
{
case BasicHeader.HeaderFormats.F0: //11 bytes
{
var timeStampByte = new byte[4] {0x00, reader.ReadByte(), reader.ReadByte(), reader.ReadByte()};
TimeStamp = EndianBitConverter.Big.ToInt32(timeStampByte, 0);
var lengthByte = new byte[4] {0x00, reader.ReadByte(), reader.ReadByte(), reader.ReadByte()};
MessageLength = EndianBitConverter.Big.ToInt32(lengthByte, 0);
MessageType = reader.ReadByte();
var messageStreamBytes = reader.ReadBytes(4);
MessageStreamId = EndianBitConverter.Little.ToInt32(messageStreamBytes, 0);
}
break;
case BasicHeader.HeaderFormats.F1: //7 bytes
{
var timeStampByte = new byte[4] {0x00, reader.ReadByte(), reader.ReadByte(), reader.ReadByte()};
TimeStamp = EndianBitConverter.Big.ToInt32(timeStampByte, 0);
var lengthByte = new byte[4] {0x00, reader.ReadByte(), reader.ReadByte(), reader.ReadByte()};
MessageLength = EndianBitConverter.Big.ToInt32(lengthByte, 0);
MessageType = reader.ReadByte();
}
break;
case BasicHeader.HeaderFormats.F2: //3 bytes
{
var timeStampByte = new byte[4] {0x00, reader.ReadByte(), reader.ReadByte(), reader.ReadByte()};
TimeStamp = EndianBitConverter.Big.ToInt32(timeStampByte, 0);
}
break;
case BasicHeader.HeaderFormats.F3: //No bytes
break;
}
}
public void read(EndianBinaryReader r) {
Time = r.ReadSingle();
Measure = r.ReadInt16();
Beat = r.ReadInt16();
PhraseIteration = r.ReadInt32();
Mask = r.ReadInt32();
}
private void readPixels(EndianBinaryReader reader, ushort width, ushort height, DmfFile file)
{
int totalPixels = width * height;
uint xLocation = 1;
uint yLocation = 1;
for (int i = 0; i < totalPixels; i++)
{
short altitude = reader.ReadInt16();
byte peakRoughness = reader.ReadByte();
byte fractalRoughness = reader.ReadByte();
byte cliffStrength = reader.ReadByte();
byte erosionStrength = reader.ReadByte();
byte autoLakeStrength = reader.ReadByte();
byte climateId = reader.ReadByte();
byte specialTypeId = reader.ReadByte();
byte specialTypeParam = reader.ReadByte();
file.addPixel(new DmfPixelInfo(xLocation, yLocation, altitude, peakRoughness, fractalRoughness, cliffStrength, erosionStrength, autoLakeStrength, climateId, specialTypeId, specialTypeParam));
xLocation++;
if (xLocation > width)
{
xLocation = 1;
yLocation++;
}
}
debugLine("pixel count: " + file.pixels.Count());
}
public static Stream ConvertOgg(string inputFile)
{
if (needsConversion(inputFile))
{
var platform = getPlatform(inputFile);
EndianBitConverter bitConverter = platform.GetBitConverter();
using (var outputFileStream = new MemoryStream())
using (var inputFileStream = File.Open(inputFile, FileMode.Open))
using (var writer = new EndianBinaryWriter(bitConverter, outputFileStream))
using (var reader = new EndianBinaryReader(bitConverter, inputFileStream))
{
writer.Write(reader.ReadBytes(4));
UInt32 fileSize = reader.ReadUInt32();
fileSize -= 8; // We're removing data, so update the size in the header
writer.Write(fileSize);
writer.Write(reader.ReadBytes(8));
writer.Write(66); reader.ReadUInt32(); // New fmt size is 66
writer.Write(reader.ReadBytes(16));
writer.Write((ushort)48); reader.ReadUInt16(); // New cbSize is 48
writer.Write(reader.ReadBytes(6));
reader.BaseStream.Seek(8, SeekOrigin.Current); // Skip ahead 8 bytes, we don't want the vorb chunk
writer.Write(reader.ReadBytes((int)reader.BaseStream.Length - (int)reader.BaseStream.Position));
return new MemoryStream(outputFileStream.GetBuffer(), 0, (int)outputFileStream.Length);
}
}
return File.OpenRead(inputFile);
}
protected override void Parse (EndianBinaryReader r)
{
/*
string channel = ReadString8(r);
Varint int length = r.ReadInt16();
if (length > MaxDataSize)
throw new InvalidDataException("Plugin package payload size > " + MaxDataSize + " bytes");
byte[] data = r.ReadBytesOrThrow(length);
switch (channel)
{
case MCItemName.ChannelID:
return new MCItemName(data);
case "MC|AdvCdm":
case "MC|Beacon":
case "MC|TPack":
case "MC|TrList":
case "MC|TrSel":
case "MC|Brand":
return new UnknownPluginMessageServer(channel, data);
default:
#if DEBUG
throw new InvalidOperationException("New Plugin channel: " + channel);
#else
return new UnknownPluginMessageServer(channel, data);
#endif
}
*/
}
private static List<Texture2D> LoadTEX1FromFile(EndianBinaryReader reader, long chunkStart)
{
ushort textureCount = reader.ReadUInt16();
ushort padding = reader.ReadUInt16(); // Usually 0xFFFF?
uint textureHeaderOffset = reader.ReadUInt32(); // textureCount # bti image headers are stored here, relative to chunkStart.
uint stringTableOffset = reader.ReadUInt32(); // One filename per texture. relative to chunkStart.
List<Texture2D> textureList = new List<Texture2D>();
// Get all Texture Names
reader.BaseStream.Position = chunkStart + stringTableOffset;
StringTable stringTable = StringTable.FromStream(reader);
for (int t = 0; t < textureCount; t++)
{
// 0x20 is the length of the BinaryTextureImage header which all come in a row, but then the stream gets jumped around while loading the BTI file.
reader.BaseStream.Position = chunkStart + textureHeaderOffset + (t * 0x20);
BinaryTextureImage texture = new BinaryTextureImage();
texture.Load(reader, chunkStart + 0x20, t);
Texture2D texture2D = new Texture2D(texture.Width, texture.Height);
texture2D.Name = stringTable[t];
texture2D.PixelData = texture.GetData();
textureList.Add(texture2D);
string executionPath = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
texture.SaveImageToDisk(executionPath + "/TextureDump/" + string.Format("{0}_({1}-{2}).png", stringTable[t], texture.Format, t));
}
return textureList;
}
static public void Fill(byte[] bytes)
{
var binReader = new EndianBinaryReader(Endian.LittleEndian, new MemoryStream(bytes));
binReader.Endian = binReader.ReadBoolean() ? Endian.LittleEndian : Endian.BigEndian;
var jumpPos = binReader.ReadInt32();
//跳过表头信息
binReader.BaseStream.Position = jumpPos;
/*
var headerCount = binReader.ReadInt32();
var headers = new string[headerCount];
var types = new string[headerCount];
for (var i = 0; i < headerCount; i++)
{
headers[i] = binReader.ReadUTF();
types[i] = binReader.ReadUTF();
}
*/
var count = binReader.ReadInt32();
for (int i = 0; i < count; i++)
{
var vo = new LangVO();
vo.decode(binReader);
list_vo.Add(vo);
dic_vo.Add(vo.Age, vo);
}
}
public static void UnpackSng(Stream input, Stream output, Platform platform) {
EndianBitConverter conv = platform.GetBitConverter;
using (var decrypted = new MemoryStream())
using (var ebrDec = new EndianBinaryReader(conv, decrypted)) {
byte[] key;
switch (platform.platform) {
case GamePlatform.Mac:
key = RijndaelEncryptor.SngKeyMac;
break;
case GamePlatform.Pc:
key = RijndaelEncryptor.SngKeyPC;
break;
default:
key = null;
break;
}
if (key != null)
RijndaelEncryptor.DecryptSngData(input, decrypted, key, conv);
else {
input.CopyTo(decrypted);
decrypted.Seek(8, SeekOrigin.Begin);
}
//unZip
long plainLen = ebrDec.ReadUInt32();
ushort xU = ebrDec.ReadUInt16();
decrypted.Position -= 2;
if (xU == 0x78DA || xU == 0xDA78) {//LE 55928 //BE 30938
RijndaelEncryptor.Unzip(decrypted, output, false);
}
}
}
public TEX0(EndianBinaryReader er)
{
long basepos = er.BaseStream.Position;
Signature = er.ReadString(Encoding.ASCII, 4);
if (Signature != "TEX0") throw new SignatureNotCorrectException(Signature, "TEX0", er.BaseStream.Position - 4);
SectionSize = er.ReadUInt32();
TexInfo = new texInfo(er);
Tex4x4Info = new tex4x4Info(er);
PlttInfo = new plttInfo(er);
dictTex = new Dictionary<DictTexData>(er);
for (int i = 0; i < dictTex.numEntry; i++)
{
dictTex[i].Value.ReadData(er, TexInfo.ofsTex, Tex4x4Info.ofsTex, Tex4x4Info.ofsTexPlttIdx, basepos);
}
dictPltt = new Dictionary<DictPlttData>(er);
List<UInt32> Offset = new List<uint>();
for (int i = 0; i < dictPltt.numEntry; i++)
{
Offset.Add(dictPltt[i].Value.offset);
}
Offset = Offset.Distinct().ToList();
Offset.Sort();
for (int i = 0; i < dictPltt.numEntry; i++)
{
int idx = Offset.IndexOf(dictPltt[i].Value.offset);
if (idx == Offset.Count - 1)
{
dictPltt[i].Value.ReadData(er, PlttInfo.ofsPlttData, (uint)er.BaseStream.Length - (Offset[idx] + PlttInfo.ofsPlttData + (uint)basepos), basepos);
}
else
{
dictPltt[i].Value.ReadData(er, PlttInfo.ofsPlttData, Offset[idx + 1] - Offset[idx], basepos);
}
}
}
public bool Update()
{
var bitStream = downloader.DownloadStream;
var reader = new EndianBinaryReader(EndianBitConverter.Big, bitStream);
if(bitStream != null)
{
var stream = new StreamReader(bitStream);
{
reader.ReadBytes(3); //"FLV"
reader.ReadBytes(6); //Other starter shit
while (true)
{
try
{
var footer = reader.ReadUInt32();
var tag = new FlvTag();
tag.Load(reader);
AddedTag(tag);
}
catch (Exception)
{
reader.Close();
//End of stream
return false;
}
}
}
}
return true;
}
public FFNT(byte[] Data)
{
EndianBinaryReader er = new EndianBinaryReader(new MemoryStream(Data), Endianness.BigEndian);
Header = new FFNTHeader(er);
FontInfo = new FINF(er);
er.BaseStream.Position = FontInfo.TGLPOffset - 8;
TextureGlyph = new TGLP(er);
List<CWDH> tmp = new List<CWDH>();
er.BaseStream.Position = FontInfo.CWDHOffset - 8;
CWDH Last;
do
{
Last = new CWDH(er);
tmp.Add(Last);
if (Last.NextCWDHOffset != 0) er.BaseStream.Position = Last.NextCWDHOffset - 8;
}
while (Last.NextCWDHOffset != 0);
CharWidths = tmp.ToArray();
List<CMAP> tmp2 = new List<CMAP>();
er.BaseStream.Position = FontInfo.CMAPOffset - 8;
CMAP Last2;
do
{
Last2 = new CMAP(er);
tmp2.Add(Last2);
if (Last2.NextCMAPOffset != 0) er.BaseStream.Position = Last2.NextCMAPOffset - 8;
}
while (Last2.NextCMAPOffset != 0);
CharMaps = tmp2.ToArray();
er.Close();
}
public wnd1(EndianBinaryReader er)
: base(er)
{
long basepos = er.BaseStream.Position - 0x4C;
InflationLeft = er.ReadUInt16() / 16f;
InflationRight = er.ReadUInt16() / 16f;
InflationTop = er.ReadUInt16() / 16f;
InflationBottom = er.ReadUInt16() / 16f;
FrameSizeLeft = er.ReadUInt16();
FrameSizeRight = er.ReadUInt16();
FrameSizeTop = er.ReadUInt16();
FrameSizeBottom = er.ReadUInt16();
NrFrames = er.ReadByte();
byte tmp = er.ReadByte();
UseLTMaterial = (tmp & 1) == 1;
UseVtxColorForAllWindow = (tmp & 2) == 2;
Kind = (WindowKind)((tmp >> 2) & 3);
DontDrawContent = (tmp & 8) == 16;
Padding = er.ReadUInt16();
ContentOffset = er.ReadUInt32();
FrameOffsetTableOffset = er.ReadUInt32();
er.BaseStream.Position = basepos + ContentOffset;
Content = new WindowContent(er);
er.BaseStream.Position = basepos + FrameOffsetTableOffset;
WindowFrameOffsets = er.ReadUInt32s(NrFrames);
WindowFrames = new WindowFrame[NrFrames];
for (int i = 0; i < NrFrames; i++)
{
er.BaseStream.Position = basepos + WindowFrameOffsets[i];
WindowFrames[i] = new WindowFrame(er);
}
er.BaseStream.Position = basepos + SectionSize;
}
//Constructors
public ByteBuffer()
{
stream = new MemoryStream();
bitConverter = new LittleEndianBitConverter();
writer = new EndianBinaryWriter(bitConverter, stream);
reader = new EndianBinaryReader(bitConverter, stream);
}
public POTIRoute(EndianBinaryReader er)
{
NrPoints = er.ReadUInt16();
Setting1 = er.ReadByte();
Setting2 = er.ReadByte();
for (int i = 0; i < NrPoints; i++) Points.Add(new POTIPoint(er));
}
public override void ClearBody()
{
base.ClearBody();
this.outputBuffer = null;
this.dataIn = null;
this.dataOut = null;
this.length = 0;
}
public static Tag Read(string path)
{
using (GZipStream gzip = new GZipStream (new FileStream (path, FileMode.Open, FileAccess.Read), CompressionMode.Decompress))
{
EndianBinaryReader r = new EndianBinaryReader(EndianBitConverter.Big, gzip);
return Tag.ReadTag(r);
}
}
public override void ClearBody()
{
base.ClearBody();
this.byteBuffer = null;
this.dataIn = null;
this.dataOut = null;
this.bytesRemaining = -1;
}
public ByteBuffer(int capacity)
{
stream = new MemoryStream();
bitConverter = new LittleEndianBitConverter();
writer = new EndianBinaryWriter(bitConverter, stream);
reader = new EndianBinaryReader(bitConverter, stream);
stream.Capacity = capacity;
}
public POTI(EndianBinaryReader er)
{
Signature = er.ReadString(Encoding.ASCII, 4);
if (Signature != "ITOP") throw new SignatureNotCorrectException(Signature, "ITOP", er.BaseStream.Position - 4);
NrRoutes = er.ReadUInt16();
NrPoints = er.ReadUInt16();
for (int i = 0; i < NrRoutes; i++) Routes.Add(new POTIRoute(er));
}
//private Socket sock;
//private IPEndPoint ipep;
//private IPAddress ipAddr;
/**
* Create the server connection
*/
public ConnectionObject(String host, int port)
{
tc = new TcpClient(host, port);
tcS = tc.GetStream();
bw = new EndianBinaryWriter(new BigEndianBitConverter(), tcS);
br = new EndianBinaryReader(new BigEndianBitConverter(), tcS);
}
public ImageTextureCtr(EndianBinaryReader er)
: base(er)
{
TextureImageOffset = (UInt32)er.BaseStream.Position + er.ReadUInt32();
long curpos = er.BaseStream.Position;
er.BaseStream.Position = TextureImageOffset;
TextureImage = new PixelBasedImageCtr(er);
er.BaseStream.Position = curpos;
}
protected MessageReader(byte[] backing)
: this()
{
if (backing != null)
{
this._ms = new MemoryStream(backing);
this.Reader = new EndianBinaryReader(Endianness, _ms);
}
}
public void read(EndianBinaryReader r) {
Solo = r.ReadByte();
Disparity = r.ReadByte();
Ignore = r.ReadByte();
Padding = r.ReadByte();
MaxDifficulty = r.ReadInt32();
PhraseIterationLinks = r.ReadInt32();
Name = r.ReadBytes(32);
}
public KCLOctree(EndianBinaryReader er, int NrNodes)
{
long baseoffset = er.BaseStream.Position;
RootNodes = new KCLOctreeNode[NrNodes];
for (int i = 0; i < NrNodes; i++)
{
RootNodes[i] = new KCLOctreeNode(er, baseoffset);
}
}
protected override void Parse(EndianBinaryReader r)
{
BlockPosition = CoordInt.Read(r);
FaceDirection = (Face)r.ReadByte();
Item = SlotItem.Read(r);
CursorX = r.ReadByte();
CursorY = r.ReadByte();
CursorZ = r.ReadByte();
}
public void ReadCharsBeyondInternalBufferSize()
{
MemoryStream stream = new MemoryStream(TestBytes);
EndianBinaryReader subject = new EndianBinaryReader(EndianBitConverter.Little, stream);
char[] chars = new char[TestString.Length];
subject.Read(chars, 0, chars.Length);
Assert.AreEqual(TestString, new string(chars));
}
protected override void Parse(EndianBinaryReader r)
{
Version = (ProtocolVersion)ReadVarInt(r);
Host = ReadString8(r);
Port = r.ReadUInt16();
State = (HandshakeState)ReadVarInt(r);
DebugGotAll(r);
}
public ByteBuffer(int capacity, int position, MemoryStream _stream)
{
stream = new MemoryStream();
bitConverter = new LittleEndianBitConverter();
writer = new EndianBinaryWriter(bitConverter, stream);
reader = new EndianBinaryReader(bitConverter, stream);
stream.Capacity = capacity;
stream.Position = position;
stream = _stream;
}
public ByteBuffer(Endianness _endianess, System.Text.Encoding _encoding)
{
stream = new MemoryStream();
if (_endianess == Endianness.BigEndian)
bitConverter = new BigEndianBitConverter();
else
bitConverter = new LittleEndianBitConverter();
writer = new EndianBinaryWriter(bitConverter, stream, _encoding);
reader = new EndianBinaryReader(bitConverter, stream, _encoding);
}
public override void FromBinaryReader(EndianBinaryReader reader)
{
SpawnId = reader.ReadInt32();
ProcessId = reader.ReadInt32();
CmdArgs = reader.ReadString();
}
private void ReadResponse()
{
using (MemoryStream ms = new MemoryStream(incomingBuffer))
using (var reader = new EndianBinaryReader(EndianBitConverter.Big, ms, Encoding.UTF8))
{
BinaryInputArchive bbia = BinaryInputArchive.GetArchive(reader);
ReplyHeader replyHdr = new ReplyHeader();
replyHdr.Deserialize(bbia, "header");
if (replyHdr.Xid == -2)
{
// -2 is the xid for pings
if (LOG.IsDebugEnabled)
{
LOG.Debug(string.Format("Got ping response for sessionid: 0x{0:X} after {1}ms", conn.SessionId, (DateTime.Now.Nanos() - lastPingSentNs) / 1000000));
}
return;
}
if (replyHdr.Xid == -4)
{
// -2 is the xid for AuthPacket
// TODO: process AuthPacket here
if (LOG.IsDebugEnabled)
{
LOG.Debug(string.Format("Got auth sessionid:0x{0:X}", conn.SessionId));
}
return;
}
if (replyHdr.Xid == -1)
{
// -1 means notification
if (LOG.IsDebugEnabled)
{
LOG.Debug(string.Format("Got notification sessionid:0x{0}", conn.SessionId));
}
WatcherEvent @event = new WatcherEvent();
@event.Deserialize(bbia, "response");
// convert from a server path to a client path
if (conn.ChrootPath != null)
{
string serverPath = @event.Path;
if (serverPath.CompareTo(conn.ChrootPath) == 0)
{
@event.Path = "/";
}
else
{
@event.Path = serverPath.Substring(conn.ChrootPath.Length);
}
}
WatchedEvent we = new WatchedEvent(@event);
if (LOG.IsDebugEnabled)
{
LOG.Debug(string.Format("Got {0} for sessionid 0x{1:X}", we, conn.SessionId));
}
conn.consumer.QueueEvent(we);
return;
}
if (pendingQueue.IsEmpty())
{
throw new IOException(string.Format("Nothing in the queue, but got {0}", replyHdr.Xid));
}
Packet packet;
lock (pendingQueueLock)
{
packet = pendingQueue.First.Value;
pendingQueue.RemoveFirst();
}
/*
* Since requests are processed in order, we better get a response
* to the first request!
*/
try
{
if (packet.header.Xid != replyHdr.Xid)
{
packet.replyHeader.Err = (int)KeeperException.Code.CONNECTIONLOSS;
throw new IOException(string.Format("Xid out of order. Got {0} expected {1}", replyHdr.Xid, packet.header.Xid));
}
packet.replyHeader.Xid = replyHdr.Xid;
packet.replyHeader.Err = replyHdr.Err;
packet.replyHeader.Zxid = replyHdr.Zxid;
if (replyHdr.Zxid > 0)
{
lastZxid = replyHdr.Zxid;
}
if (packet.response != null && replyHdr.Err == 0)
{
packet.response.Deserialize(bbia, "response");
}
if (LOG.IsDebugEnabled)
{
LOG.Debug(string.Format("Reading reply sessionid:0x{0:X}, packet:: {1}", conn.SessionId, packet));
}
}
finally
{
FinishPacket(packet);
}
}
}
private static List <T> LoadVertexAttribute <T>(EndianBinaryReader reader, int totalAttributeDataLength, byte decimalPoint, VertexArrayType arrayType, VertexDataType dataType, VertexColorType colorType) where T : new()
{
int componentCount = 0;
switch (arrayType)
{
case VertexArrayType.Position:
case VertexArrayType.Normal:
componentCount = 3;
break;
case VertexArrayType.Color0:
case VertexArrayType.Color1:
componentCount = 4;
break;
case VertexArrayType.Tex0:
case VertexArrayType.Tex1:
case VertexArrayType.Tex2:
case VertexArrayType.Tex3:
case VertexArrayType.Tex4:
case VertexArrayType.Tex5:
case VertexArrayType.Tex6:
case VertexArrayType.Tex7:
componentCount = 2;
break;
default:
WLog.Warning(LogCategory.ModelLoading, null, "Unsupported ArrayType \"{0}\" found while loading VTX1!", arrayType);
break;
}
// We need to know the length of each 'vertex' (which can vary based on how many attributes and what types there are)
int vertexSize = 0;
switch (dataType)
{
case VertexDataType.Float32:
vertexSize = componentCount * 4;
break;
case VertexDataType.Unsigned16:
case VertexDataType.Signed16:
vertexSize = componentCount * 2;
break;
case VertexDataType.Signed8:
case VertexDataType.Unsigned8:
vertexSize = componentCount * 1;
break;
case VertexDataType.None:
break;
default:
WLog.Warning(LogCategory.ModelLoading, null, "Unsupported DataType \"{0}\" found while loading VTX1!", dataType);
break;
}
switch (colorType)
{
case VertexColorType.RGB8:
vertexSize = 3;
break;
case VertexColorType.RGBX8:
case VertexColorType.RGBA8:
vertexSize = 4;
break;
case VertexColorType.None:
break;
case VertexColorType.RGB565:
case VertexColorType.RGBA4:
case VertexColorType.RGBA6:
default:
WLog.Warning(LogCategory.ModelLoading, null, "Unsupported Color Data Type: {0}!", colorType);
break;
}
int sectionSize = totalAttributeDataLength / vertexSize;
List <T> values = new List <T>(sectionSize);
float scaleFactor = (float)Math.Pow(0.5, decimalPoint);
for (int v = 0; v < sectionSize; v++)
{
// Create a default version of the object and then fill it up depending on our component count and its data type...
dynamic value = new T();
for (int i = 0; i < componentCount; i++)
{
switch (dataType)
{
case VertexDataType.Float32:
value[i] = reader.ReadSingle() * scaleFactor;
break;
case VertexDataType.Unsigned16:
value[i] = (float)reader.ReadUInt16() * scaleFactor;
break;
case VertexDataType.Signed16:
value[i] = (float)reader.ReadInt16() * scaleFactor;
break;
case VertexDataType.Unsigned8:
value[i] = (float)reader.ReadByte() * scaleFactor;
break;
case VertexDataType.Signed8:
value[i] = (float)reader.ReadSByte() * scaleFactor;
break;
case VertexDataType.None:
// Let the next switch statement get it.
break;
default:
WLog.Warning(LogCategory.ModelLoading, null, "Unsupported Data Type: {0}!", dataType);
break;
}
switch (colorType)
{
case VertexColorType.RGBX8:
case VertexColorType.RGB8:
case VertexColorType.RGBA8:
value[i] = reader.ReadByte() / 255f;
break;
case VertexColorType.None:
break;
case VertexColorType.RGB565:
case VertexColorType.RGBA4:
case VertexColorType.RGBA6:
default:
WLog.Warning(LogCategory.ModelLoading, null, "Unsupported Color Data Type: {0}!", colorType);
break;
}
}
values.Add(value);
}
return(values);
}
public DestroyItem(EndianBinaryReader reader)
{
Hash = Encoding.UTF8.GetString(reader.ReadBytes(reader.ReadUInt16()));
CollectedByPlayer = reader.ReadBoolean();
reader.ReadInt16();
}
/// <summary> /// Parse the buffer into class parameters /// </summary> protected abstract void Parse(EndianBinaryReader r);
public DDSHeader(Stream stream, bool leaveOpen = true)
{
using (var reader = new EndianBinaryReader(stream, Encoding.Default, leaveOpen, Endianness.LittleEndian))
Read(reader);
}
public override void FromBinaryReader(EndianBinaryReader reader)
{
LobbyId = reader.ReadString();
TeamName = reader.ReadString();
}
public ScriptContext(EndianBinaryReader r)
{
_reader = r;
}
protected override void Parse(EndianBinaryReader r)
{
EID = ReadVarInt(r);
Position = CoordInt.Read(r);
}
public static Stream ConvertAudioPlatform(string inputFile)
{
inputFile.VerifyHeaders();
var platform = inputFile.GetAudioPlatform();
EndianBitConverter bitConverter;
EndianBitConverter targetbitConverter;
if (!platform.IsConsole)
{
bitConverter = EndianBitConverter.Little;
targetbitConverter = EndianBitConverter.Big;
}
else if (platform.IsConsole)
{
bitConverter = EndianBitConverter.Big;
targetbitConverter = EndianBitConverter.Little;
}
else
{
throw new InvalidDataException("The input file doesn't appear to be a valid Wwise file.");
}
using (var outputFileStream = new MemoryStream())
using (var inputFileStream = File.Open(inputFile, FileMode.Open))
using (var writer = new EndianBinaryWriter(targetbitConverter, outputFileStream))
using (var reader = new EndianBinaryReader(bitConverter, inputFileStream))
{
// Process Header
UInt32 header = reader.ReadUInt32();
if (header == 1179011410)//RIFF header to RIFX
//raw
{
writer.Write(1380533848);
}
else
{
//raw
writer.Write(1179011410); // 1179011410
}
writer.Write(reader.ReadUInt32()); // Size of File
//raw
writer.Write(reader.ReadBytes(4)); // WAVE (RIFF type)
//Process Format
writer.Write(reader.ReadBytes(4)); // fmt magicID //raw
writer.Write(reader.ReadUInt32()); // fmt size
writer.Write(reader.ReadUInt16()); // fmt tag (-1)
writer.Write(reader.ReadUInt16()); // channels
writer.Write(reader.ReadUInt32()); // samplesPerSec
writer.Write(reader.ReadUInt32()); // avgBytesPerSec //SeekTableGranulary?
writer.Write(reader.ReadUInt16()); // blockAlign
writer.Write(reader.ReadUInt16()); // bitsPerSample
writer.Write(reader.ReadUInt16()); //short cbSize 0-22 // WAVEFORMATEXTENSIBLE
writer.Write(reader.ReadUInt16()); //short wSamplesPerBlock; // WAVEFORMATEXTENSIBLE
writer.Write(reader.ReadUInt32()); //long dwChannelMask; // WAVEFORMATEXTENSIBLE
writer.Write(reader.ReadUInt32()); //long dwTotalPCMFrames; // Wwise
UInt32 start = reader.ReadUInt32();
writer.Write(start); //long dwLoopStartPacketOffset; // Wwise
UInt32 end = reader.ReadUInt32();
writer.Write(end); //long dwLoopEndPacketOffset; // Wwise
writer.Write(reader.ReadUInt16()); //short uLoopBeginExtra; // Wwise
writer.Write(reader.ReadUInt16()); //short uLoopEndExtra; // Wwise
UInt32 seektablesize = reader.ReadUInt32();
writer.Write(seektablesize); //long dwSeekTableSize; // Wwise
writer.Write(reader.ReadUInt32()); //long dwVorbisDataOffset; // Wwise
writer.Write(reader.ReadUInt16()); //short uMaxPacketSize; // Wwise
writer.Write(reader.ReadUInt16()); //short uLastGranuleExtra; // Wwise
writer.Write(reader.ReadUInt32()); //long dwDecodeAllocSize; // Wwise
writer.Write(reader.ReadUInt32()); //long dwDecodeX64AllocSize; // Wwise
//raw
writer.Write(reader.ReadBytes(4)); //long uHashCodebook; // Wwise vorbis_analysis_headerout
writer.Write(reader.ReadByte()); //char uBlockSizes[2]; // Wwise
writer.Write(reader.ReadByte()); //char uBlockSizes[2]; // Wwise
// Process DATA section - contains size, seektable, codebook, stream (biggest part)
//raw data
writer.Write(reader.ReadBytes(4)); // the word data
writer.Write(reader.ReadUInt32()); //data size
//seektable
var y = seektablesize / 4;
for (int i = 0; i < y; i++)
{
writer.Write(reader.ReadUInt16()); //seekgranularity
writer.Write(reader.ReadUInt16()); //unk. actual granularity used??
}
//codebook
UInt16 codebooksize = reader.ReadUInt16();
writer.Write(codebooksize); //codebook size
for (int i = 0; i < codebooksize; i++)
{
//raw data
writer.Write(reader.ReadByte());
}
//stream
var streamsize = (end - start); //calculate the total stream size till End of File
for (int i = 0; i < streamsize; i++)
{
UInt16 packetsize = reader.ReadUInt16(); // size of packet
i++; // increase because two bytes read for size of packet
writer.Write(packetsize);
for (int z = 0; z < packetsize; z++)
{
Byte packet = reader.ReadByte();
writer.Write(packet); // the packets are the same in both pc/console
i++; // add the bytes read to packetsize counter.
}
}
return(new MemoryStream(outputFileStream.GetBuffer(), 0, (int)outputFileStream.Length));
}
}
public Stop(EndianBinaryReader r)
{
SheetTile = r.ReadInt32();
Time = r.ReadInt32();
}
internal void LoadNonIndexed(EndianBinaryReader input, uint vertexFlags, bool is16Bit)
{
// Make sure that only known flags are set
if ((vertexFlags & (uint)~(GcmfVertexFlags.TransformMatrixRef |
GcmfVertexFlags.Coordinates |
GcmfVertexFlags.Normals |
GcmfVertexFlags.Color |
GcmfVertexFlags.PrimaryTextureCoordinates |
GcmfVertexFlags.SecondaryTextureCoordinates |
GcmfVertexFlags.TertiaryTextureCoordinates |
GcmfVertexFlags.NormalBitangentTangent)) != 0)
{
throw new InvalidGmaFileException("[GcmfVertexNonIndexed] Unknown vertex flags.");
}
if ((vertexFlags & (uint)GcmfVertexFlags.Coordinates) == 0)
{
throw new InvalidGmaFileException("[GcmfVertexNonIndexed] No coordinates flag.");
}
if ((vertexFlags & (uint)GcmfVertexFlags.TransformMatrixRef) != 0)
{
TransformMatrixRef = input.ReadByte();
}
Position = new Vector3(
ReadNumberOfType(input, is16Bit),
ReadNumberOfType(input, is16Bit),
ReadNumberOfType(input, is16Bit));
if ((vertexFlags & (uint)GcmfVertexFlags.Normals) != 0)
{
Normal = new Vector3(
ReadNumberOfType(input, is16Bit),
ReadNumberOfType(input, is16Bit),
ReadNumberOfType(input, is16Bit));
}
if ((vertexFlags & (uint)GcmfVertexFlags.Color) != 0)
{
VertexColor = UnpackColorRGBA(input.ReadUInt32());
}
if ((vertexFlags & (uint)GcmfVertexFlags.PrimaryTextureCoordinates) != 0)
{
PrimaryTexCoord = new Vector2(
ReadNumberOfType(input, is16Bit),
ReadNumberOfType(input, is16Bit));
}
if ((vertexFlags & (uint)GcmfVertexFlags.SecondaryTextureCoordinates) != 0)
{
SecondaryTexCoord = new Vector2(
ReadNumberOfType(input, is16Bit),
ReadNumberOfType(input, is16Bit));
}
if ((vertexFlags & (uint)GcmfVertexFlags.TertiaryTextureCoordinates) != 0)
{
TertiaryTexCoord = new Vector2(
ReadNumberOfType(input, is16Bit),
ReadNumberOfType(input, is16Bit));
}
if ((vertexFlags & (uint)GcmfVertexFlags.NormalBitangentTangent) != 0)
{
// TODO should this use readNum or is it always a float?
Normal2 = new Vector3(
ReadNumberOfType(input, false),
ReadNumberOfType(input, false),
ReadNumberOfType(input, false));
Bitangent = new Vector3(
ReadNumberOfType(input, false),
ReadNumberOfType(input, false),
ReadNumberOfType(input, false));
Tangent = new Vector3(
ReadNumberOfType(input, false),
ReadNumberOfType(input, false),
ReadNumberOfType(input, false));
}
}
private static IReadOnlyDictionary <string, object> Read(EndianBinaryReader reader, IReadOnlyList <ClassMember> classMembers, int startIndex, int baseLevel, bool fastReturn)
{
var dict = new Dictionary <string, object>();
for (var i = startIndex; i < classMembers.Count; ++i)
{
var member = classMembers[i];
var level = member.Level;
if (level <= baseLevel && fastReturn)
{
return(dict);
}
var varName = member.Name;
var varType = member.TypeName;
var shouldAlign = (member.Flags & 0x4000) != 0;
object value;
IReadOnlyList <ClassMember> subList;
switch (varType)
{
case "SInt8":
value = reader.ReadSByte();
break;
case "UInt8":
value = reader.ReadByte();
break;
case "SInt16":
case "short":
value = reader.ReadInt16();
break;
case "UInt16":
case "unsigned short":
value = reader.ReadUInt16();
break;
case "SInt32":
case "int":
value = reader.ReadInt32();
break;
case "UInt32":
case "unsigned int":
value = reader.ReadUInt32();
break;
case "SInt64":
case "long long":
value = reader.ReadInt64();
break;
case "UInt64":
case "unsigned long long":
value = reader.ReadUInt64();
break;
case "float":
value = reader.ReadSingle();
break;
case "double":
value = reader.ReadDouble();
break;
case "bool":
value = reader.ReadBoolean();
break;
case "string":
var strLen = reader.ReadInt32();
value = reader.ReadAlignedString(strLen);
i += 3;
break;
case "Array":
if (i > 0 && (classMembers[i - 1].Flags & 0x4000) != 0)
{
shouldAlign = true;
}
var size = reader.ReadInt32();
subList = ReadSubObjectList(classMembers, level, i + 2);
var list = new List <object>();
for (var j = 0; j < size; ++j)
{
var d2 = Read(reader, subList);
list.Add(d2);
}
// '1' for "size" field.
i += 1 + subList.Count;
value = list;
break;
default:
var customType = new CustomType {
TypeName = varType,
Name = varName,
Level = level
};
subList = ReadSubObjectList(classMembers, level, i + 1);
var objects = Read(reader, subList);
customType.Variables = objects;
value = customType;
i += subList.Count;
shouldAlign = false;
break;
}
dict[varName] = value;
if (shouldAlign)
{
reader.AlignBy(4);
}
}
return(dict);
}
public FieldScene(string filePath) : this()
{
using (var reader = new EndianBinaryReader(new MemoryStream(File.ReadAllBytes(filePath)), filePath, Endianness.Little))
Read(reader);
}
private static IReadOnlyDictionary <string, object> Read(EndianBinaryReader reader, IReadOnlyList <ClassMember> classMembers, int startIndex)
{
return(Read(reader, classMembers, startIndex, 0, false));
}
public SSEQReleaseRateEvent(byte EventID, EndianBinaryReader er)
{
this.EventID = EventID;
this.ReleaseRate = er.ReadByte();
}
static public BinaryInputArchive GetArchive(EndianBinaryReader reader)
{
return(new BinaryInputArchive(reader));
}
private MeshVertexAttributeHolder LoadVTX1FromFile(EndianBinaryReader reader, long chunkStart, int chunkSize)
{
MeshVertexAttributeHolder dataHolder = new MeshVertexAttributeHolder();
//long headerStart = reader.BaseStream.Position;
int vertexFormatOffset = reader.ReadInt32();
int[] vertexDataOffsets = new int[13];
for (int k = 0; k < vertexDataOffsets.Length; k++)
{
vertexDataOffsets[k] = reader.ReadInt32();
}
reader.BaseStream.Position = chunkStart + vertexFormatOffset;
List <VertexFormat> vertexFormats = new List <VertexFormat>();
VertexFormat curFormat = null;
do
{
curFormat = new VertexFormat();
curFormat.ArrayType = (VertexArrayType)reader.ReadInt32();
curFormat.ComponentCount = reader.ReadInt32();
curFormat.DataType = (VertexDataType)reader.ReadInt32();
curFormat.ColorDataType = (VertexColorType)curFormat.DataType;
curFormat.DecimalPoint = reader.ReadByte();
reader.ReadBytes(3); // Padding
vertexFormats.Add(curFormat);
} while (curFormat.ArrayType != VertexArrayType.NullAttr);
// Don't count the last vertexFormat as it's the NullAttr one.
dataHolder.Attributes = vertexFormats.GetRange(0, vertexFormats.Count - 1);
// Now that we know how the vertexes are described, we can get the various data.
for (int k = 0; k < vertexDataOffsets.Length; k++)
{
if (vertexDataOffsets[k] == 0)
{
continue;
}
// Get the total length of this block of data.
int totalLength = GetVertexDataLength(vertexDataOffsets, k, (int)(chunkSize));
VertexFormat vertexFormat = null;
reader.BaseStream.Position = chunkStart + vertexDataOffsets[k];
switch (k)
{
// Position Data
case 0:
vertexFormat = vertexFormats.Find(x => x.ArrayType == VertexArrayType.Position);
dataHolder.Position = LoadVertexAttribute <Vector3>(reader, totalLength, vertexFormat.DecimalPoint, VertexArrayType.Position, vertexFormat.DataType, VertexColorType.None);
break;
// Normal Data
case 1:
vertexFormat = vertexFormats.Find(x => x.ArrayType == VertexArrayType.Normal);
dataHolder.Normal = LoadVertexAttribute <Vector3>(reader, totalLength, vertexFormat.DecimalPoint, VertexArrayType.Normal, vertexFormat.DataType, VertexColorType.None);
break;
// Normal Binormal Tangent Data (presumed)
case 2:
break;
// Color 0 Data
case 3:
vertexFormat = vertexFormats.Find(x => x.ArrayType == VertexArrayType.Color0);
dataHolder.Color0 = LoadVertexAttribute <Color>(reader, totalLength, vertexFormat.DecimalPoint, VertexArrayType.Color0, VertexDataType.None, vertexFormat.ColorDataType);
break;
// Color 1 Data (presumed)
case 4:
vertexFormat = vertexFormats.Find(x => x.ArrayType == VertexArrayType.Color1);
dataHolder.Color1 = LoadVertexAttribute <Color>(reader, totalLength, vertexFormat.DecimalPoint, VertexArrayType.Color1, VertexDataType.None, vertexFormat.ColorDataType);
break;
// Tex 0 Data
case 5:
vertexFormat = vertexFormats.Find(x => x.ArrayType == VertexArrayType.Tex0);
dataHolder.Tex0 = LoadVertexAttribute <Vector2>(reader, totalLength, vertexFormat.DecimalPoint, VertexArrayType.Tex0, vertexFormat.DataType, VertexColorType.None);
break;
// Tex 1 Data
case 6:
vertexFormat = vertexFormats.Find(x => x.ArrayType == VertexArrayType.Tex1);
dataHolder.Tex1 = LoadVertexAttribute <Vector2>(reader, totalLength, vertexFormat.DecimalPoint, VertexArrayType.Tex1, vertexFormat.DataType, VertexColorType.None);
break;
// Tex 2 Data
case 7:
vertexFormat = vertexFormats.Find(x => x.ArrayType == VertexArrayType.Tex2);
dataHolder.Tex2 = LoadVertexAttribute <Vector2>(reader, totalLength, vertexFormat.DecimalPoint, VertexArrayType.Tex2, vertexFormat.DataType, VertexColorType.None);
break;
// Tex 3 Data
case 8:
vertexFormat = vertexFormats.Find(x => x.ArrayType == VertexArrayType.Tex3);
dataHolder.Tex3 = LoadVertexAttribute <Vector2>(reader, totalLength, vertexFormat.DecimalPoint, VertexArrayType.Tex3, vertexFormat.DataType, VertexColorType.None);
break;
// Tex 4 Data
case 9:
vertexFormat = vertexFormats.Find(x => x.ArrayType == VertexArrayType.Tex4);
dataHolder.Tex4 = LoadVertexAttribute <Vector2>(reader, totalLength, vertexFormat.DecimalPoint, VertexArrayType.Tex4, vertexFormat.DataType, VertexColorType.None);
break;
// Tex 5 Data
case 10:
vertexFormat = vertexFormats.Find(x => x.ArrayType == VertexArrayType.Tex5);
dataHolder.Tex5 = LoadVertexAttribute <Vector2>(reader, totalLength, vertexFormat.DecimalPoint, VertexArrayType.Tex5, vertexFormat.DataType, VertexColorType.None);
break;
// Tex 6 Data
case 11:
vertexFormat = vertexFormats.Find(x => x.ArrayType == VertexArrayType.Tex6);
dataHolder.Tex6 = LoadVertexAttribute <Vector2>(reader, totalLength, vertexFormat.DecimalPoint, VertexArrayType.Tex6, vertexFormat.DataType, VertexColorType.None);
break;
// Tex 7 Data
case 12:
vertexFormat = vertexFormats.Find(x => x.ArrayType == VertexArrayType.Tex7);
dataHolder.Tex7 = LoadVertexAttribute <Vector2>(reader, totalLength, vertexFormat.DecimalPoint, VertexArrayType.Tex7, vertexFormat.DataType, VertexColorType.None);
break;
}
}
return(dataHolder);
}
/** Creates a new instance of BinaryInputArchive */
public BinaryInputArchive(EndianBinaryReader reader)
{
this.reader = reader;
}
public void ReadFields(EndianBinaryReader reader)
{
BinaryInputArchive archive = new BinaryInputArchive(reader);
this.Deserialize(archive, string.Empty);
}
public FieldScene(Stream stream, bool leaveOpen = false) : this()
{
using (var reader = new EndianBinaryReader(stream, leaveOpen, Endianness.Little))
Read(reader);
}
public IModel LoadModel(ModlModelFileBundle modelFileBundle)
{
var flipSign = ModlFlags.FLIP_HORIZONTALLY ? -1 : 1;
var modlFile = modelFileBundle.ModlFile;
using var er = new EndianBinaryReader(modlFile.Impl.OpenRead(),
Endianness.LittleEndian);
var bwModel = modelFileBundle.ModlType switch {
ModlType.BW1 => (IModl)er.ReadNew <Bw1Modl>(),
ModlType.BW2 => er.ReadNew <Bw2Modl>(),
};
var model = new ModelImpl();
var finMesh = model.Skin.AddMesh();
var finBones = new IBone[bwModel.Nodes.Count];
var finBonesByModlNode = new Dictionary <IBwNode, IBone>();
var finBonesByIdentifier = new Dictionary <string, IBone>();
{
var nodeQueue =
new FinTuple2Queue <IBone, ushort>((model.Skeleton.Root, 0));
while (nodeQueue.TryDequeue(out var parentFinBone,
out var modlNodeId))
{
var modlNode = bwModel.Nodes[modlNodeId];
var transform = modlNode.Transform;
var bonePosition = transform.Position;
var modlRotation = transform.Rotation;
var rotation = new Quaternion(
flipSign * modlRotation.X,
modlRotation.Y,
modlRotation.Z,
flipSign * modlRotation.W);
var eulerRadians = QuaternionUtil.ToEulerRadians(rotation);
var finBone =
parentFinBone
.AddChild(flipSign * bonePosition.X, bonePosition.Y,
bonePosition.Z)
.SetLocalRotationRadians(
eulerRadians.X, eulerRadians.Y, eulerRadians.Z);
var identifier = modlNode.GetIdentifier();
finBone.Name = identifier;
finBones[modlNodeId] = finBone;
finBonesByModlNode[modlNode] = finBone;
finBonesByIdentifier[identifier] = finBone;
if (bwModel.CnctParentToChildren.TryGetList(
modlNodeId, out var modlChildIds))
{
nodeQueue.Enqueue(
modlChildIds !.Select(modlChildId => (finBone, modlChildId)));
}
}
foreach (var animFile in modelFileBundle.AnimFiles ??
Array.Empty <IFileHierarchyFile>())
{
var anim = modelFileBundle.ModlType switch {
ModlType.BW1 => (IAnim)animFile.Impl.ReadNew <Bw1Anim>(
Endianness.BigEndian),
ModlType.BW2 => animFile.Impl.ReadNew <Bw2Anim>(
Endianness.BigEndian)
};
var maxFrameCount = -1;
foreach (var animBone in anim.AnimBones)
{
maxFrameCount = (int)Math.Max(maxFrameCount,
Math.Max(
animBone
.PositionKeyframeCount,
animBone
.RotationKeyframeCount));
}
var finAnimation = model.AnimationManager.AddAnimation();
finAnimation.Name = animFile.NameWithoutExtension;
finAnimation.FrameRate = 30;
finAnimation.FrameCount = maxFrameCount;
for (var b = 0; b < anim.AnimBones.Count; ++b)
{
var animBone = anim.AnimBones[b];
var animBoneFrames = anim.AnimBoneFrames[b];
var animNodeIdentifier = animBone.GetIdentifier();
if (!finBonesByIdentifier.TryGetValue(
animNodeIdentifier, out var finBone))
{
// TODO: Gross hack for the vet models, what's the real fix???
if (animNodeIdentifier == Bw1Node.GetIdentifier(33))
{
finBone = finBonesByIdentifier[Bw1Node.GetIdentifier(34)];
}
else if (finBonesByIdentifier.TryGetValue(
animNodeIdentifier + 'X', out var xBone))
{
finBone = xBone;
}
else if (finBonesByIdentifier.TryGetValue(
"BONE_" + animNodeIdentifier,
out var prefixBone))
{
finBone = prefixBone;
}
else if (animNodeIdentifier == "WF_GRUNT_BACKPAC")
{
// TODO: Is this right?????
finBone = finBonesByIdentifier["BONE_BCK_MISC"];
}
else
{
;
}
}
var finBoneTracks = finAnimation.AddBoneTracks(finBone !);
var fbtPositions = finBoneTracks.Positions;
for (var f = 0; f < animBone.PositionKeyframeCount; ++f)
{
var(fPX, fPY, fPZ) = animBoneFrames.PositionFrames[f];
fbtPositions.Set(f, 0, flipSign * fPX);
fbtPositions.Set(f, 1, fPY);
fbtPositions.Set(f, 2, fPZ);
}
var fbtRotations = finBoneTracks.Rotations;
for (var f = 0; f < animBone.RotationKeyframeCount; ++f)
{
var(fRX, fRY, fRZ, frW) = animBoneFrames.RotationFrames[f];
var animationQuaternion =
new Quaternion(flipSign * fRX, fRY, fRZ, flipSign * frW);
var eulerRadians =
QuaternionUtil.ToEulerRadians(animationQuaternion);
fbtRotations.Set(f, 0, eulerRadians.X);
fbtRotations.Set(f, 1, eulerRadians.Y);
fbtRotations.Set(f, 2, eulerRadians.Z);
}
}
}
var textureDictionary = new LazyDictionary <string, ITexture>(
textureName => {
var textureFile =
modlFile.Parent.Files.Single(
file => file.Name.ToLower() == $"{textureName}.png");
var image = FinImage.FromFile(textureFile.Impl);
var finTexture =
model.MaterialManager.CreateTexture(image);
finTexture.Name = textureName;
// TODO: Need to handle wrapping
finTexture.WrapModeU = WrapMode.REPEAT;
finTexture.WrapModeV = WrapMode.REPEAT;
return(finTexture);
});
foreach (var modlNode in bwModel.Nodes)
{
var finMaterials =
modlNode.Materials.Select(modlMaterial => {
var textureName = modlMaterial.Texture1.ToLower();
if (textureName == "")
{
return(null);
}
var finTexture = textureDictionary[textureName];
var finMaterial =
model.MaterialManager
.AddTextureMaterial(finTexture);
return(finMaterial);
})
.ToArray();
foreach (var modlMesh in modlNode.Meshes)
{
var finMaterial = finMaterials[modlMesh.MaterialIndex];
foreach (var triangleStrip in modlMesh.TriangleStrips)
{
var vertices =
new IVertex[triangleStrip.VertexAttributeIndicesList.Count];
for (var i = 0; i < vertices.Length; i++)
{
var vertexAttributeIndices =
triangleStrip.VertexAttributeIndicesList[i];
var position =
modlNode.Positions[vertexAttributeIndices.PositionIndex];
var vertex = vertices[i] = model.Skin.AddVertex(
flipSign * position.X * modlNode.Scale,
position.Y * modlNode.Scale,
position.Z * modlNode.Scale);
if (vertexAttributeIndices.NormalIndex != null)
{
var normal =
modlNode.Normals[
vertexAttributeIndices.NormalIndex.Value];
vertex.SetLocalNormal(flipSign * normal.X, normal.Y,
normal.Z);
}
if (vertexAttributeIndices.NodeIndex != null)
{
var finBone =
finBones[vertexAttributeIndices.NodeIndex.Value];
vertex.SetBoneWeights(
model.Skin
.GetOrCreateBoneWeights(
PreprojectMode.NONE,
new BoneWeight(finBone, null, 1)));
}
else
{
var finBone = finBonesByModlNode[modlNode];
vertex.SetBoneWeights(
model.Skin.GetOrCreateBoneWeights(
PreprojectMode.BONE, finBone));
}
var texCoordIndex0 = vertexAttributeIndices.TexCoordIndices[0];
var texCoordIndex1 = vertexAttributeIndices.TexCoordIndices[1];
if (texCoordIndex1 != null)
{
int texCoordIndex;
if (texCoordIndex0 != null)
{
texCoordIndex =
(texCoordIndex0.Value << 8) | texCoordIndex1.Value;
}
else
{
texCoordIndex = texCoordIndex1.Value;
}
var uv = modlNode.UvMaps[0][texCoordIndex];
vertex.SetUv(uv.U, uv.V);
}
}
var triangleStripPrimitive = finMesh.AddTriangleStrip(vertices);
if (finMaterial != null)
{
triangleStripPrimitive.SetMaterial(finMaterial);
}
}
}
}
}
return(model);
}
}
public PSFSv1File(EndianBinaryReader reader)
{
Filename = Encoding.ASCII.GetString(reader.ReadBytes(0x30)).TrimEnd('\0');
FileSize = reader.ReadInt64();
Offset = reader.ReadInt64();
}
//DCMTK djcodecd.cxx
public static int ScanJpegForBitDepth(DicomPixelData pixelData)
{
DicomItem item = pixelData.Dataset.Get <DicomItem>(DicomTag.PixelData);
IByteBuffer buffer;
if (item is DicomFragmentSequence)
{
buffer = (item as DicomFragmentSequence).Fragments[0];
}
else
{
buffer = (item as DicomElement).Buffer;
}
MemoryStream ms = new MemoryStream(buffer.Data);
BinaryReader br = EndianBinaryReader.Create(ms, Endian.Big);
long length = ms.Length;
while (ms.Position < length)
{
ushort marker = br.ReadUInt16();
switch (marker)
{
case 0xffc0: // SOF_0: JPEG baseline
case 0xffc1: // SOF_1: JPEG extended sequential DCT
case 0xffc2: // SOF_2: JPEG progressive DCT
case 0xffc3: // SOF_3: JPEG lossless sequential
case 0xffc5: // SOF_5: differential (hierarchical) extended sequential, Huffman
case 0xffc6: // SOF_6: differential (hierarchical) progressive, Huffman
case 0xffc7: // SOF_7: differential (hierarchical) lossless, Huffman
ms.Seek(2, SeekOrigin.Current);
return((int)br.ReadByte());
case 0xffc8: // Reserved for JPEG extentions
ms.Seek(br.ReadUInt16() - 2, SeekOrigin.Current);
break;
case 0xffc9: // SOF_9: extended sequential, arithmetic
case 0xffca: // SOF_10: progressive, arithmetic
case 0xffcb: // SOF_11: lossless, arithmetic
case 0xffcd: // SOF_13: differential (hierarchical) extended sequential, arithmetic
case 0xffce: // SOF_14: differential (hierarchical) progressive, arithmetic
case 0xffcf: // SOF_15: differential (hierarchical) lossless, arithmetic
ms.Seek(2, SeekOrigin.Current);
return((int)br.ReadByte());
case 0xffc4: // DHT
case 0xffcc: // DAC
ms.Seek(br.ReadUInt16() - 2, SeekOrigin.Current);
break;
case 0xffd0: // RST m
case 0xffd1:
case 0xffd2:
case 0xffd3:
case 0xffd4:
case 0xffd5:
case 0xffd6:
case 0xffd7:
case 0xffd8: // SOI
case 0xffd9: // EOI
break;
case 0xffda: // SOS
case 0xffdb: // DQT
case 0xffdc: // DNL
case 0xffdd: // DRI
case 0xffde: // DHP
case 0xffdf: // EXP
case 0xffe0: // APPn
case 0xffe1:
case 0xffe2:
case 0xffe3:
case 0xffe4:
case 0xffe5:
case 0xffe6:
case 0xffe7:
case 0xffe8:
case 0xffe9:
case 0xffea:
case 0xffeb:
case 0xffec:
case 0xffed:
case 0xffee:
case 0xffef:
case 0xfff0: // JPGn
case 0xfff1:
case 0xfff2:
case 0xfff3:
case 0xfff4:
case 0xfff5:
case 0xfff6:
case 0xfff7:
case 0xfff8:
case 0xfff9:
case 0xfffa:
case 0xfffb:
case 0xfffc:
case 0xfffd:
case 0xfffe: // COM
ms.Seek(br.ReadUInt16() - 2, SeekOrigin.Current);
break;
case 0xff01: // TEM
break;
default:
int b1 = br.ReadByte();
int b2 = br.ReadByte();
if (b1 == 0xff && b2 > 2 && b2 <= 0xbf) // RES reserved markers
{
break;
}
else
{
throw new DicomCodecException("Unable to determine bit depth: JPEG syntax error!");
}
}
}
throw new DicomCodecException("Unable to determine bit depth: no JPEG SOF marker found!");
}
protected void SkipParse(EndianBinaryReader r)
{
r.BaseStream.Seek(0, SeekOrigin.End);
}
public void ReadFields(EndianBinaryReader reader)
{
this.Deserialize((IInputArchive) new BinaryInputArchive(reader), string.Empty);
}
private void LoadTagDataFromFile(EndianBinaryReader reader)
{
long tagStart = reader.BaseStream.Position;
string tagName = reader.ReadString(4);
int tagSize = reader.ReadInt32();
LoopMode = (LoopType)reader.ReadByte();
byte angleMultiplier = reader.ReadByte(); // Probably just padding in BRK
AnimLengthInFrames = reader.ReadInt16();
short colorAnimEntryCount = reader.ReadInt16();
short konstAnimEntryCount = reader.ReadInt16();
short numColorREntries = reader.ReadInt16();
short numColorGEntries = reader.ReadInt16();
short numColorBEntries = reader.ReadInt16();
short numColorAEntries = reader.ReadInt16();
short numKonstREntries = reader.ReadInt16();
short numKonstGEntries = reader.ReadInt16();
short numKonstBEntries = reader.ReadInt16();
short numKonstAEntries = reader.ReadInt16();
int colorAnimDataOffset = reader.ReadInt32();
int konstAnimDataOffset = reader.ReadInt32();
int colorRemapTableOffset = reader.ReadInt32();
int konstRemapTableOffset = reader.ReadInt32();
int colorStringTableOffset = reader.ReadInt32();
int konstStringTableOffset = reader.ReadInt32();
int colorRTableOffset = reader.ReadInt32();
int colorGTableOffset = reader.ReadInt32();
int colorBTableOffset = reader.ReadInt32();
int colorATableOffset = reader.ReadInt32();
int konstRTableOffset = reader.ReadInt32();
int konstGTableOffset = reader.ReadInt32();
int konstBTableOffset = reader.ReadInt32();
int konstATableOffset = reader.ReadInt32();
reader.Skip(8); // padding
float[] colorRData = new float[numColorREntries];
reader.BaseStream.Position = tagStart + colorRTableOffset;
for (int i = 0; i < numColorREntries; i++)
{
colorRData[i] = reader.ReadInt16();
}
float[] colorGData = new float[numColorGEntries];
reader.BaseStream.Position = tagStart + colorGTableOffset;
for (int i = 0; i < numColorGEntries; i++)
{
colorGData[i] = reader.ReadInt16();
}
float[] colorBData = new float[numColorBEntries];
reader.BaseStream.Position = tagStart + colorBTableOffset;
for (int i = 0; i < numColorBEntries; i++)
{
colorBData[i] = reader.ReadInt16();
}
float[] colorAData = new float[numColorAEntries];
reader.BaseStream.Position = tagStart + colorATableOffset;
for (int i = 0; i < numColorAEntries; i++)
{
colorAData[i] = reader.ReadInt16();
}
float[] konstRData = new float[numKonstREntries];
reader.BaseStream.Position = tagStart + konstRTableOffset;
for (int i = 0; i < numKonstREntries; i++)
{
konstRData[i] = reader.ReadInt16();
}
float[] konstGData = new float[numKonstGEntries];
reader.BaseStream.Position = tagStart + konstGTableOffset;
for (int i = 0; i < numKonstGEntries; i++)
{
konstGData[i] = reader.ReadInt16();
}
float[] konstBData = new float[numKonstBEntries];
reader.BaseStream.Position = tagStart + konstBTableOffset;
for (int i = 0; i < numKonstBEntries; i++)
{
konstBData[i] = reader.ReadInt16();
}
float[] konstAData = new float[numKonstAEntries];
reader.BaseStream.Position = tagStart + konstATableOffset;
for (int i = 0; i < numKonstAEntries; i++)
{
konstAData[i] = reader.ReadInt16();
}
m_colorRemapTable = new int[colorAnimEntryCount];
reader.BaseStream.Position = tagStart + colorRemapTableOffset;
for (int i = 0; i < colorAnimEntryCount; i++)
{
m_colorRemapTable[i] = reader.ReadInt16();
}
m_konstRemapTable = new int[konstAnimEntryCount];
reader.BaseStream.Position = tagStart + konstRemapTableOffset;
for (int i = 0; i < konstAnimEntryCount; i++)
{
m_konstRemapTable[i] = reader.ReadInt16();
}
reader.BaseStream.Position = tagStart + colorStringTableOffset;
m_colorStringTable = StringTable.FromStream(reader);
reader.BaseStream.Position = tagStart + konstStringTableOffset;
m_konstStringTable = StringTable.FromStream(reader);
m_colorAnimationData = new List <RegisterAnim>();
reader.BaseStream.Position = tagStart + colorAnimDataOffset;
for (int i = 0; i < colorAnimEntryCount; i++)
{
AnimIndex colorRIndex = ReadAnimIndex(reader);
AnimIndex colorGIndex = ReadAnimIndex(reader);
AnimIndex colorBIndex = ReadAnimIndex(reader);
AnimIndex colorAIndex = ReadAnimIndex(reader);
int colorID = reader.ReadByte();
reader.Skip(3);
RegisterAnim regAnim = new RegisterAnim();
regAnim.ColorID = colorID;
regAnim.RedChannel = ReadComp(colorRData, colorRIndex);
regAnim.GreenChannel = ReadComp(colorGData, colorGIndex);
regAnim.BlueChannel = ReadComp(colorBData, colorBIndex);
regAnim.AlphaChannel = ReadComp(colorAData, colorAIndex);
foreach (Key key in regAnim.RedChannel)
{
key.Value = key.Value / 255.0f;
key.TangentIn = (float)key.TangentIn / 65535.0f;
key.TangentOut = (float)key.TangentOut / 65535.0f;
}
foreach (Key key in regAnim.GreenChannel)
{
key.Value = key.Value / 255.0f;
key.TangentIn = (float)key.TangentIn / 65535.0f;
key.TangentOut = (float)key.TangentOut / 65535.0f;
}
foreach (Key key in regAnim.BlueChannel)
{
key.Value = key.Value / 255.0f;
key.TangentIn = (float)key.TangentIn / 65535.0f;
key.TangentOut = (float)key.TangentOut / 65535.0f;
}
foreach (Key key in regAnim.AlphaChannel)
{
key.Value = key.Value / 255.0f;
key.TangentIn = (float)key.TangentIn / 65535.0f;
key.TangentOut = (float)key.TangentOut / 65535.0f;
}
m_colorAnimationData.Add(regAnim);
}
m_konstAnimationData = new List <RegisterAnim>();
reader.BaseStream.Position = tagStart + konstAnimDataOffset;
for (int i = 0; i < konstAnimEntryCount; i++)
{
AnimIndex konstRIndex = ReadAnimIndex(reader);
AnimIndex konstGIndex = ReadAnimIndex(reader);
AnimIndex konstBIndex = ReadAnimIndex(reader);
AnimIndex konstAIndex = ReadAnimIndex(reader);
int colorID = reader.ReadByte();
reader.Skip(3);
RegisterAnim regAnim = new RegisterAnim();
regAnim.ColorID = colorID;
regAnim.RedChannel = ReadComp(konstRData, konstRIndex);
regAnim.GreenChannel = ReadComp(konstGData, konstGIndex);
regAnim.BlueChannel = ReadComp(konstBData, konstBIndex);
regAnim.AlphaChannel = ReadComp(konstAData, konstAIndex);
foreach (Key key in regAnim.RedChannel)
{
key.Value = key.Value / 65535.0f;
key.TangentIn = (float)key.TangentIn / 65535.0f;
key.TangentOut = (float)key.TangentOut / 65535.0f;
}
foreach (Key key in regAnim.GreenChannel)
{
key.Value = key.Value / 255.0f;
key.TangentIn = (float)key.TangentIn / 65535.0f;
key.TangentOut = (float)key.TangentOut / 65535.0f;
}
foreach (Key key in regAnim.BlueChannel)
{
key.Value = key.Value / 255.0f;
key.TangentIn = (float)key.TangentIn / 65535.0f;
key.TangentOut = (float)key.TangentOut / 65535.0f;
}
foreach (Key key in regAnim.AlphaChannel)
{
key.Value = key.Value / 255.0f;
key.TangentIn = (float)key.TangentIn / 65535.0f;
key.TangentOut = (float)key.TangentOut / 65535.0f;
}
m_konstAnimationData.Add(regAnim);
}
}
internal void Read(EndianBinaryReader reader, bool isModern)
{
if (Type == KeySetType.Static)
{
Keys.Add(new Key {
Value = reader.ReadSingle()
});
}
else if (Type != KeySetType.None)
{
IsInterpolated = Type == KeySetType.Interpolated;
if (isModern)
{
ReadModern();
}
else
{
ReadClassic();
}
void ReadClassic()
{
ushort keyCount = reader.ReadUInt16();
Keys.Capacity = keyCount;
for (int i = 0; i < keyCount; i++)
{
Keys.Add(new Key {
Frame = reader.ReadUInt16()
});
}
reader.Align(4);
foreach (var key in Keys)
{
key.Value = reader.ReadSingle();
if (IsInterpolated)
{
key.Interpolation = reader.ReadSingle();
}
}
}
void ReadModern()
{
ushort keyCount = reader.ReadUInt16();
ushort type = reader.ReadUInt16();
Keys.Capacity = keyCount;
for (int i = 0; i < keyCount; i++)
{
Keys.Add(new Key());
}
if (IsInterpolated)
{
foreach (var key in Keys)
{
key.Interpolation = reader.ReadSingle();
}
}
reader.Align(4);
foreach (var key in Keys)
{
key.Value = type == 1
? reader.ReadHalf()
: reader.ReadSingle();
}
reader.Align(4);
foreach (var key in Keys)
{
key.Frame = reader.ReadUInt16();
}
reader.Align(4);
}
}
}
private static void Main(string[] args)
{
ConfigureLogging();
string flatFilename = null;
string structuredOut = null;
string disassemblyFile = null;
var options = new OptionSet
{
{ "f|flat=", "Dump flat output to file", _ => flatFilename = _ },
{ "o|out=", "Dump structured output to file", _ => structuredOut = _ },
{ "d|disassembly=", "Disassemble associated .exe when available to file", _ => disassemblyFile = _ }
};
IList <string> extraArgs;
try
{
extraArgs = options.Parse(args);
}
catch (OptionException e)
{
logger.Error(e.Message);
options.WriteOptionDescriptions(Console.Out);
Console.WriteLine("Note that '-' is a valid filename, resulting in outputting to the console");
return;
}
if (extraArgs.Count != 1)
{
logger.Error("Please provide a .SYM file for processing");
options.WriteOptionDescriptions(Console.Out);
Console.WriteLine("Note that '-' is a valid filename, resulting in outputting to the console");
return;
}
if (flatFilename != null)
{
logger.Info($"Dumping {extraArgs[0]} to {flatFilename} in flat format");
using (var fs = new FileStream(extraArgs[0], FileMode.Open))
{
// ReSharper disable once ObjectCreationAsStatement
new SymFile(new BinaryReader(fs), flatFilename);
}
}
if (structuredOut == null && disassemblyFile == null)
{
return;
}
SymFile symFile;
using (var fs = new FileStream(extraArgs[0], FileMode.Open))
{
symFile = new SymFile(new BinaryReader(fs), null);
if (structuredOut != null)
{
logger.Info($"Dumping {extraArgs[0]} to {structuredOut} in structured format");
using (var outFs = structuredOut == "-" ? Console.Out : File.CreateText(structuredOut))
{
symFile.Dump(outFs);
}
}
}
if (disassemblyFile == null)
{
return;
}
var exeFilename = Path.ChangeExtension(extraArgs[0], "EXE");
if (!File.Exists(exeFilename))
{
logger.Warn($"EXE file {exeFilename} does not exist, skipping disassembly");
return;
}
logger.Info($"Dumping {exeFilename} disassembly to {disassemblyFile}");
using (var fs = new EndianBinaryReader(new FileStream(exeFilename, FileMode.Open)))
{
var exeFile = new ExeFile(fs, symFile);
exeFile.Disassemble();
using (var outFs = disassemblyFile == "-" ? Console.Out : File.CreateText(disassemblyFile))
using (var writer = new IndentedTextWriter(outFs))
{
exeFile.Dump(writer);
}
}
}
public override void Read(EndianBinaryReader er)
{
offset = (uint)(er.ReadUInt16() << 3);
flag = er.ReadUInt16();
}
