public RoGndCubeData(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version) {
Height = bin.ReadVector4();
TileUp = bin.ReadInt32();
TileSide = bin.ReadInt32();
TileAside = bin.ReadInt32();
}
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;
}
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 GenericFileFormatData(BinaryReader reader, GenericFileFormatVersion version) {
mReader = reader;
mVersion = version;
if (mReader != null) {
Read();
}
}
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 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 GenericFileFormatData(BinaryReader reader, GenericFileFormatVersion version)
{
mReader = reader;
mVersion = version;
if (mReader != null)
{
Read();
}
}
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 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();
}
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()
};
}
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 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;
}
}
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 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 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 DrawableRoRsmMesh(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version) {
}
public RoGndGridData(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version) {
X = bin.ReadUInt32();
Y = bin.ReadUInt32();
Cells = bin.ReadUInt32();
}
public RoRsmMeshHeader(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version) {
Name = bin.ReadWord(40);
ParentName = bin.ReadWord(40);
}
public RoRsmMeshTextureVertex(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version) {
Color = (version.IsCompatible(1, 2) == false ? 0xFFFFFFFF : bin.ReadUInt32());
U = bin.ReadSingle();
V = bin.ReadSingle();
}
protected override bool ReadInternal() {
ImagesPal = new List<RoSpriteImagePal>();
ImagesRgba = new List<RoSpriteImageRgba>();
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 \\
RoSpriteImagePal imgPal;
for (int i = 0; i < imgPalCount; i++) {
imgPal = new RoSpriteImagePal() {
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 \\
RoSpriteImageRgba imgRgba;
for (int i = 0; i < imgRgbaCount; i++) {
imgRgba = new RoSpriteImageRgba() {
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 RoRsmMeshRotationFrame(BinaryReader bin, GenericFileFormatVersion version)
: base(bin, version) {
Frame = bin.ReadInt32();
Rotation = bin.ReadVector3();
}
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;
}
