public RoRsmMeshTextureVertex(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version)
{
Color = (version.IsCompatible(1, 2) == false ? 0xFFFFFFFF : bin.ReadUInt32());
U = bin.ReadSingle();
V = bin.ReadSingle();
}
public RoGndGridData(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version)
{
X = bin.ReadUInt32();
Y = bin.ReadUInt32();
Cells = bin.ReadUInt32();
}
public RoRswDataWater(BinaryReader reader, GenericFileFormatVersion version)
: base(reader, version)
{
Height = 0;
Type = 0;
Amplitude = 1;
Phase = 2;
SurfaceCurveLevel = 0.5f;
TextureCycling = 3;
if (version.IsCompatible(1, 3))
{
Height = reader.ReadSingle();
if (version.IsCompatible(1, 8))
{
Type = reader.ReadUInt32();
Amplitude = reader.ReadSingle();
Phase = reader.ReadSingle();
SurfaceCurveLevel = reader.ReadSingle();
if (version.IsCompatible(1, 9))
{
TextureCycling = reader.ReadInt32();
}
}
}
}
public RoRsmMeshSurface(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version)
{
SurfaceVector = new ushort[3];
TextureVector = new ushort[3];
for (int i = 0; i < SurfaceVector.Length; i++)
{
SurfaceVector[i] = bin.ReadUInt16();
}
for (int i = 0; i < TextureVector.Length; i++)
{
TextureVector[i] = bin.ReadUInt16();
}
TextureID = bin.ReadUInt16();
Padding = bin.ReadUInt16();
TwoSide = bin.ReadUInt32();
if (version.IsCompatible(1, 2))
{
SmoothGroup = bin.ReadUInt32();
}
else
{
SmoothGroup = 0;
}
}
public RoGndCubeData(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version)
{
Height = bin.ReadVector4();
TileUp = bin.ReadInt32();
TileSide = bin.ReadInt32();
TileAside = bin.ReadInt32();
}
public char[] color; // BGRA -- "A" seems to be ignored by the official client
public RoGndTileData(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version)
{
VectorWidth = bin.ReadVector4();
VectorHeight = bin.ReadVector4();
TextureIndex = bin.ReadUInt16();
Lightmap = bin.ReadUInt16();
color = bin.ReadChars(4);
}
public RoRsmMeshTransMatrix(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version)
{
Matrix = bin.ReadMatrix();
Position = bin.ReadVector3();
RotationAngle = bin.ReadSingle();
RotationAxis = bin.ReadVector3();
Scale = bin.ReadVector3();
}
public RoRswDataLight(BinaryReader reader, GenericFileFormatVersion version)
: base(reader, version)
{
name = reader.ReadWord(40);
pos = reader.ReadVector3();
unk1 = reader.ReadChars(40);
color = reader.ReadVector3();
unk2 = reader.ReadSingle();
}
public RoGndTextureData(BinaryReader bin, GenericFileFormatVersion version, string texRootPath, GraphicsDevice device)
: base(bin, version)
{
TexturePath = bin.ReadWord(40).ToLower();
Unknown = bin.ReadWord(40).ToCharArray();
TextureBmp = Bitmap.FromFile(texRootPath + @"\" + TexturePath) as Bitmap;
if (device != null)
{
}
}
public int[] unk3; // 2
public RoRswDataEffect(BinaryReader reader, GenericFileFormatVersion version)
: base(reader, version)
{
name = reader.ReadWord(40);
unk1 = reader.ReadSingle();
category = reader.ReadInt32();
pos = reader.ReadVector3();
type = reader.ReadInt32();
loop = reader.ReadSingle();
unk2 = new float[2] {
reader.ReadSingle(),
reader.ReadSingle()
};
unk3 = new int[2] {
reader.ReadInt32(),
reader.ReadInt32()
};
}
public float[] unk; // 8
public RoRswDataSound(BinaryReader reader, GenericFileFormatVersion version)
: base(reader, version)
{
name = reader.ReadWord(80);
filename = reader.ReadWord(80);
// TODO: Looks like a matrix
unk = new float[8] {
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle()
};
}
protected override bool ReadInternal()
{
// Header
Reader.BaseStream.Position += 4;
Version = new GenericFileFormatVersion(Reader);
Width = Reader.ReadUInt32();
Height = Reader.ReadUInt32();
Ratio = Reader.ReadUInt32();
TextureCount = Reader.ReadUInt32();
TextureSize = Reader.ReadUInt32();
Textures = new RoGndTextureData[TextureCount];
for (int i = 0; i < TextureCount; i++)
{
Textures[i] = new RoGndTextureData(Reader, Version, mTextureRootPath);
}
LightmapCount = Reader.ReadInt32();
Grid = new RoGndGridData(Reader, Version);
Lightmaps = new RoGndLitghmapData[LightmapCount];
for (int i = 0; i < LightmapCount; i++)
{
Lightmaps[i] = new RoGndLitghmapData(Reader, Version);
}
TileCount = Reader.ReadInt32();
Tiles = new RoGndTileData[TileCount];
for (int i = 0; i < TileCount; i++)
{
Tiles[i] = new RoGndTileData(Reader, Version);
}
CubeCount = Width * Height;
Cubes = new RoGndCubeData[CubeCount];
for (int i = 0; i < CubeCount; i++)
{
Cubes[i] = new RoGndCubeData(Reader, Version);
}
return(true);
}
public RoRswDataModel(BinaryReader reader, GenericFileFormatVersion version)
: base(reader, version)
{
name = reader.ReadWord(40);
if (version.IsCompatible(1, 3))
{
unk1 = reader.ReadInt32();
unk2 = reader.ReadSingle();
unk3 = reader.ReadSingle();
}
filename = reader.ReadWord(40);
reserved = reader.ReadWord(40);
type = reader.ReadWord(20);
sound = reader.ReadWord(20);
todo1 = reader.ReadWord(40);
pos = reader.ReadVector3();
rot = reader.ReadVector3();
scale = reader.ReadVector3();
}
protected override bool ReadInternal()
{
MagicHead = Reader.ReadChars(4);
Version = new GenericFileFormatVersion(Reader);
AnimationLen = Reader.ReadInt32();
ShadowType = Reader.ReadInt32();
if (Version.IsCompatible(1, 4))
{
Alpha = Reader.ReadByte();
}
Reader.BaseStream.Position += 16;
TextureNameCount = Reader.ReadInt32();
TextureNames = new string[TextureNameCount];
for (int i = 0; i < TextureNameCount; i++)
{
TextureNames[i] = Reader.ReadWord(40);
}
MainNode = Reader.ReadWord(40);
int nodeCount = Reader.ReadInt32();
for (int i = 0; i < nodeCount; i++)
{
ReadMesh();
}
if (Meshes.Count == 1)
{
Meshes[0].IsOnly = true;
}
return(true);
}
protected override bool ReadInternal()
{
ImagesPal = new List <DrawableRoSpriteImagePal>();
ImagesRgba = new List <DrawableRoSpriteImageRgba>();
Palette = new RoPalette();
MagicHead = Reader.ReadChars(2);
if (MagicHead[0] != 0x53 || MagicHead[1] != 0x50)
{
// Invalid header
return(false);
}
Version = new GenericFileFormatVersion(Reader);
if (Version.Major > 2)
{
// Unsupported version
return(false);
}
int imgPalCount = Reader.ReadUInt16();
int imgRgbaCount = 0;
if (Version >= 0x201)
{
imgRgbaCount = Reader.ReadUInt16();
}
// Images - Palette \\
DrawableRoSpriteImagePal imgPal;
for (int i = 0; i < imgPalCount; i++)
{
imgPal = new DrawableRoSpriteImagePal()
{
Width = Reader.ReadUInt16(),
Height = Reader.ReadUInt16()
};
if (Version >= 0x201)
{
imgPal.Size = Reader.ReadUInt16();
}
else
{
imgPal.Size = (ushort)(imgPal.Width * imgPal.Height);
}
imgPal.Data = Reader.ReadBytes(imgPal.Size);
ImagesPal.Add(imgPal);
}
// Images - RGBA \\
DrawableRoSpriteImageRgba imgRgba;
for (int i = 0; i < imgRgbaCount; i++)
{
imgRgba = new DrawableRoSpriteImageRgba()
{
Width = Reader.ReadUInt16(),
Height = Reader.ReadUInt16()
};
int size = (imgRgba.Width * imgRgba.Height * 4);
imgRgba.Data = Reader.ReadBytes(size);
ImagesRgba.Add(imgRgba);
}
// Palette \\
Reader.BaseStream.Position = (Reader.BaseStream.Length - (4 * RoPalette.ColorCount));
Palette.Read(Reader.BaseStream);
Flush();
return(true);
}
public RoGndTextureData(BinaryReader bin, GenericFileFormatVersion version, string texRootPath)
: this(bin, version, texRootPath, null)
{
}
protected override bool ReadInternal()
{
if (base.ReadInternal() == false)
{
return(false);
}
// skip Magic Header
Reader.BaseStream.Position += 4; // GRSW
Version = new GenericFileFormatVersion(Reader);
mIniFile = Reader.ReadWord(40);
mGndFile = Reader.ReadWord(40);
if (Version.IsCompatible(1, 4))
{
mGatFile = Reader.ReadWord(40);
}
mWaterData = new RoRswDataWater(Reader, Version);
// Unknown Byte Skipping
if (Version.IsCompatible(1, 4))
{
int i1 = Reader.ReadInt32(); // angle(?) in degrees
int i2 = Reader.ReadInt32(); // angle(?) in degrees
Vector3 v1 = Reader.ReadVector3(); // some sort of Vector3D
Vector3 v2 = Reader.ReadVector3(); // some sort of Vector3D
}
if (Version.IsCompatible(1, 7))
{
float f1 = Reader.ReadSingle();
}
if (Version.IsCompatible(1, 6))
{
int i1 = Reader.ReadInt32();
int i2 = Reader.ReadInt32();
int i3 = Reader.ReadInt32();
int i4 = Reader.ReadInt32();
}
// reading Objects
uint objCount = Reader.ReadUInt32();
RoRswDataModel m;
RoRswDataLight l;
RoRswDataSound s;
RoRswDataEffect e;
//System.Diagnostics.Debug.WriteLine( "reading " + objCount + " Objects from RWS File" );
for (int i = 0; i < objCount; i++)
{
if (Reader.BaseStream.Position + 4 >= Reader.BaseStream.Length)
{
break;
}
int objType = Reader.ReadInt32();
if (objType < 1 || objType > 4)
{
//System.Diagnostics.Debug.WriteLine( "- UNKNOWN Object (" + objType + ") @ " + i );
continue;
}
// 1 = Model
// 2 = Light
// 3 = Sound
// 4 = Effect
if (objType == 1)
{
try {
//System.Diagnostics.Debug.WriteLine( "- found Model @ Obj " + i );
m = new RoRswDataModel(Reader, Version);
mModelData.Add(m);
} catch {
continue;
}
}
else if (objType == 2)
{
try {
//System.Diagnostics.Debug.WriteLine( "- found Light @ Obj " + i );
l = new RoRswDataLight(Reader, Version);
mLightData.Add(l);
} catch {
continue;
}
}
else if (objType == 3)
{
try {
//System.Diagnostics.Debug.WriteLine( "- found Sound @ Obj " + i );
s = new RoRswDataSound(Reader, Version);
mSoundData.Add(s);
} catch {
continue;
}
}
else if (objType == 4)
{
try {
//System.Diagnostics.Debug.WriteLine( "- found Effect @ Obj " + i );
e = new RoRswDataEffect(Reader, Version);
mEffectData.Add(e);
} catch {
continue;
}
}
}
return(true);
}
public RoRsmMeshPositionFrame(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version)
{
Frame = bin.ReadInt32();
Position = bin.ReadVector4();
}
public char[] colorrbg; // size: 192
public RoGndLitghmapData(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version)
{
brightness = bin.ReadChars(64);
colorrbg = bin.ReadChars(192);
}
public RoRsmMesh(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version)
{
int count;
Head = new RoRsmMeshHeader(bin, version);
count = bin.ReadInt32();
if ((bin.BaseStream.Length - bin.BaseStream.Position) < (4 * count))
{
IsValid = false;
return;
}
for (int i = 0; i < count; i++)
{
TextureIndexs.Add(bin.ReadInt32());
}
Matrix = new RoRsmMeshTransMatrix(bin, version);
count = bin.ReadInt32();
if ((bin.BaseStream.Length - bin.BaseStream.Position) < (9 * count))
{
IsValid = false;
return;
}
for (int i = 0; i < count; i++)
{
MainVectors.Add(bin.ReadVector3());
}
count = bin.ReadInt32();
for (int i = 0; i < count; i++)
{
TextureVectors.Add(new RoRsmMeshTextureVertex(bin, version));
}
count = bin.ReadInt32();
for (int i = 0; i < count; i++)
{
Surfaces.Add(new RoRsmMeshSurface(bin, version));
}
if (version.IsCompatible(1, 5))
{
count = bin.ReadInt32();
for (int i = 0; i < count; i++)
{
PositionFrames.Add(new RoRsmMeshPositionFrame(bin, version));
}
}
count = bin.ReadInt32();
for (int i = 0; i < count; i++)
{
RotationFrames.Add(new RoRsmMeshRotationFrame(bin, version));
}
IsValid = true;
}
public DrawableRoRsmMesh(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version)
{
}
protected override bool ReadInternal()
{
Actions = new RoActionList();
Sounds = new RoActionSoundList();
Intervals = new RoActionIntervalList();
Actions.Clear();
Sounds.Clear();
Intervals.Clear();
char[] magicHead = Reader.ReadChars(2);
MajorVersion = Reader.ReadByte();
MinorVersion = Reader.ReadByte();
Reader.BaseStream.Seek(-2, System.IO.SeekOrigin.Current);
Version = new GenericFileFormatVersion(Reader);
string versionString = "0x" + Version.ToString();
if (Version > 0x205)
{
throw new Exception("Unsupported action format 0x" + versionString);
}
short animationCount = Reader.ReadInt16();
Reader.BaseStream.Seek(10, System.IO.SeekOrigin.Current);
RoAction ani;
RoActionFrame frame;
RoActionFrameImage img;
for (int a = 0; a < animationCount; a++)
{
int frameCount = Reader.ReadInt32();
ani = new RoAction();
for (int f = 0; f < frameCount; f++)
{
frame = new RoActionFrame {
Index = f,
SoundNo = 0,
ExtraX = 0,
ExtraY = 0
};
Reader.BaseStream.Seek(16, System.IO.SeekOrigin.Current); // range1 RECT{left,top,right,bottom}
Reader.BaseStream.Seek(16, System.IO.SeekOrigin.Current); // range1 RECT{left,top,right,bottom}
int imageCount = Reader.ReadInt32();
for (int i = 0; i < imageCount; i++)
{
img = new RoActionFrameImage {
OffsetX = Reader.ReadInt32(),
OffsetY = Reader.ReadInt32(),
ImageIndex = Reader.ReadInt32(),
Direction = Reader.ReadInt32(),
Color = System.Drawing.Color.White,
Rotation = 0,
ScaleX = 1,
ScaleY = 1,
Width = 0,
Height = 0
};
// Version >= 2
if (Version >= 0x200)
{
img.Color = Reader.ReadRoSpriteColor(false);
// Version <= 2.3
if (Version <= 0x203)
{
img.ScaleX = img.ScaleY = Reader.ReadSingle();
}
else
{
// Version > 2.3
img.ScaleX = Reader.ReadSingle();
img.ScaleY = Reader.ReadSingle();
}
img.Rotation = Reader.ReadInt32();
img.RgbImage = (Reader.ReadInt32() == 1);
if (Version >= 0x205)
{
img.Width = Reader.ReadInt32();
img.Height = Reader.ReadInt32();
}
}
frame.Add(img);
}
if (Version >= 0x200)
{
frame.SoundNo = Reader.ReadInt32();
frame.ExtraX = frame.ExtraY = 0;
if (Version >= 0x203)
{
int extrainfo = Reader.ReadInt32();
// TODO: Maybe its a list, but dont know how to handle more than one extra offsets
if (extrainfo > 0)
{
Reader.BaseStream.Seek(4, System.IO.SeekOrigin.Current);
frame.ExtraX = Reader.ReadInt32();
frame.ExtraY = Reader.ReadInt32();
Reader.BaseStream.Seek(4, System.IO.SeekOrigin.Current);
}
}
}
ani.Add(frame);
}
Actions.Add(ani);
}
// Sounds
if (Version >= 0x0201)
{
int soundNum = Reader.ReadInt32();
string[] soundNames = new string[soundNum];
for (int i = 0; i < soundNames.Length; i++)
{
soundNames[i] = new String(Reader.ReadChars(40));
soundNames[i] = soundNames[i].Replace("\0", "");
}
Sounds.AddRange(soundNames);
soundNames = null;
}
// Interval
if (Version >= 0x0202)
{
float[] intervals = new float[animationCount];
for (int i = 0; i < intervals.Length; i++)
{
intervals[i] = Reader.ReadSingle() * 25f;
}
Intervals.AddRange(intervals);
intervals = null;
}
else
{
for (int i = 0; i < animationCount; i++)
{
Intervals.Add(100f);
}
}
Flush();
return(true);
}
public RoRsmMeshHeader(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version)
{
Name = bin.ReadWord(40);
ParentName = bin.ReadWord(40);
}
