public override object Read(BinaryReader reader, bool xnb)
{
Type type = typeof(T);
TypeHandler handler = FmbUtil.GetTypeHandler(type);
bool isValueType = type.IsValueType();
FmbHelper.Log("List: Position: " + reader.BaseStream.Position);
int capacity = reader.ReadInt32();
#if DEBUG
FmbHelper.Log("T: " + type.FullName);
FmbHelper.Log("Capacity: " + capacity);
FmbHelper.Log("XNB: " + xnb);
FmbHelper.Log("T is ValueType: " + isValueType);
List <T> obj = new List <T>(0);
#else
List <T> obj = new List <T>(capacity);
#endif
for (int i = 0; i < capacity; i++)
{
if (isValueType || !xnb)
{
obj.Add(handler.Read <T>(reader, xnb));
}
else
{
int readerIndex = reader.Read7BitEncodedInt(); //FmbLib ain't no care about reader index.
obj.Add(readerIndex > 0 ? handler.Read <T>(reader, xnb) : default(T));
}
}
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
AnimatedTexture obj = new AnimatedTexture();
int width = reader.ReadInt32();
int height = reader.ReadInt32();
obj.FrameWidth = reader.ReadInt32();
obj.FrameHeight = reader.ReadInt32();
int dataSize = reader.ReadInt32();
Texture2D texture = Texture2DHandler.GenTexture(width, height, SurfaceFormat.Color, 1);
#if XNA
//For XNA, we simply pass the data for the only level.
texture.SetData(0, null, reader.ReadBytes(dataSize), 0, dataSize);
#elif UNITY
//Oh, Unity, wh~ oh, just one level. Continue on.
texture.LoadRawTextureData(Texture2DHandler.Remap(reader.ReadBytes(dataSize), SurfaceFormat.Color));
//updateMipmaps is true by default; makeNoLongerReadable should be false.
texture.Apply(false, FmbUtil.Setup.TexturesWriteOnly);
#endif
obj.Texture = texture;
FrameContent[] list = FmbUtil.ReadObject <List <FrameContent> >(reader, xnb).ToArray();
obj.Offsets = FmbHelper.Select <FrameContent, Rectangle>(list, delegate(FrameContent x) { return(x.Rectangle); });
obj.Timing = new AnimationTiming(0, list.Length - 1, FmbHelper.Select <FrameContent, float>(list, delegate(FrameContent x) { return((float)x.Duration.TotalSeconds); }));
obj.PotOffset = new Vector2((float)(FmbHelper.NextPowerOfTwo(obj.FrameWidth) - obj.FrameWidth), (float)(FmbHelper.NextPowerOfTwo(obj.FrameHeight) - obj.FrameHeight));
return(obj);
}
public AnimationTiming(int startFrame, int endFrame, bool loop, float[] frameTimings)
{
Loop = loop;
FrameTimings = FmbHelper.Select <float>(frameTimings, delegate(float x) { return(x != 0f ? x : 0.1f); });
stepPerFrame = 1f / (float)frameTimings.Length;
InitialFirstFrame = StartFrame = startFrame;
InitialEndFrame = EndFrame = endFrame;
}
public override void Write(BinaryWriter writer, object obj_)
{
FmbHelper.Log("Writing Texture2Ds will not be implemented - use external images and read / write manually!");
writer.Write((int)0); //surfaceFormat
writer.Write((int)0); //width
writer.Write((int)0); //height
writer.Write((int)0); //mips
//writer.Write((int) 0); //data length
}
public override void Write(BinaryWriter writer, object obj_)
{
Volume obj = (Volume)obj_;
FmbUtil.WriteObject(writer, FmbHelper.HashSetOrListToArray <FaceOrientation>(obj.Orientations));
FmbUtil.GetTypeHandler <Vector3>().Write(writer, obj.From);
FmbUtil.GetTypeHandler <Vector3>().Write(writer, obj.To);
FmbUtil.WriteObject(writer, obj.ActorSettings);
}
public override object Read(BinaryReader reader, bool xnb)
{
Volume obj = new Volume();
obj.Orientations = FmbHelper.HashSetOrList <FaceOrientation>(FmbUtil.ReadObject <FaceOrientation[]>(reader, xnb), FaceOrientationComparer.Default);
obj.From = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.To = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.ActorSettings = FmbUtil.ReadObject <VolumeActorSettings>(reader, xnb);
return(obj);
}
public override void Write(BinaryWriter writer, object obj_)
{
AnimatedTexture obj = (AnimatedTexture)obj_;
writer.Write((int)-1);
writer.Write((int)-1);
writer.Write(obj.FrameWidth);
writer.Write(obj.FrameHeight);
writer.Write((int)0);
FmbHelper.Log("TODO: ANIMATED TEXTURE WRITER");
FmbHelper.Log("TODO: ANIMATED TEXTURE WRITER");
FmbHelper.Log("TODO: ANIMATED TEXTURE WRITER");
}
public override object Read(BinaryReader reader, bool xnb)
{
Type keyType = typeof(TKey);
Type valueType = typeof(TValue);
TypeHandler keyHandler = FmbUtil.GetTypeHandler(keyType);
TypeHandler valueHandler = FmbUtil.GetTypeHandler(valueType);
bool keyIsValueType = keyType.IsValueType();
bool valueIsValueType = valueType.IsValueType();
int capacity = reader.ReadInt32();
#if DEBUG
FmbHelper.Log("TKey: " + keyType.FullName);
FmbHelper.Log("TValue: " + valueType.FullName);
FmbHelper.Log("Capacity: " + capacity);
FmbHelper.Log("XNB: " + xnb);
FmbHelper.Log("TKey is ValueType: " + keyIsValueType);
FmbHelper.Log("TValue is ValueType: " + valueIsValueType);
Dictionary <TKey, TValue> obj = new Dictionary <TKey, TValue>(0);
#else
Dictionary <TKey, TValue> obj = new Dictionary <TKey, TValue>(capacity);
#endif
for (int i = 0; i < capacity; i++)
{
TKey key;
if (keyIsValueType || !xnb)
{
key = keyHandler.Read <TKey>(reader, xnb);
}
else
{
int readerIndex = reader.ReadByte(); //FmbLib ain't no care about reader index.
key = readerIndex > 0 ? keyHandler.Read <TKey>(reader, xnb) : default(TKey);
}
TValue value;
if (valueIsValueType || !xnb)
{
value = valueHandler.Read <TValue>(reader, xnb);
}
else
{
int readerIndex = reader.ReadByte(); //FmbLib ain't no care about reader index.
value = readerIndex > 0 ? valueHandler.Read <TValue>(reader, xnb) : default(TValue);
}
obj.Add(key, value);
}
return(obj);
}
public override void Write(BinaryWriter writer, object obj_)
{
Level obj = (Level)obj_;
FmbHelper.Log("debug: Level: Name: " + obj.Name);
FmbUtil.WriteObject(writer, obj.Name);
FmbUtil.GetTypeHandler <Vector3>().Write(writer, obj.Size);
FmbUtil.WriteObject(writer, obj.StartingPosition);
FmbHelper.Log("debug: Level: SequenceSamplesPath: " + obj.SequenceSamplesPath);
FmbUtil.WriteObject(writer, obj.SequenceSamplesPath);
writer.Write(obj.Flat);
writer.Write(obj.SkipPostProcess);
writer.Write(obj.BaseDiffuse);
writer.Write(obj.BaseAmbient);
FmbHelper.Log("debug: Level: GomezHaloName: " + obj.GomezHaloName);
FmbUtil.WriteObject(writer, obj.GomezHaloName);
writer.Write(obj.HaloFiltering);
writer.Write(obj.BlinkingAlpha);
writer.Write(obj.Loops);
FmbUtil.WriteObject(writer, obj.WaterType);
writer.Write(obj.WaterHeight);
writer.Write(obj.SkyName);
FmbHelper.Log("debug: Level: TrileSetName: " + obj.TrileSetName);
FmbUtil.WriteObject(writer, obj.TrileSetName);
FmbUtil.WriteObject(writer, obj.Volumes);
FmbUtil.WriteObject(writer, obj.Scripts);
FmbUtil.WriteObject(writer, obj.SongName);
writer.Write(obj.FAPFadeOutStart);
writer.Write(obj.FAPFadeOutLength);
FmbUtil.WriteObject(writer, obj.Triles);
FmbUtil.WriteObject(writer, obj.ArtObjects);
FmbUtil.WriteObject(writer, obj.BackgroundPlanes);
FmbUtil.WriteObject(writer, obj.Groups);
FmbUtil.WriteObject(writer, obj.NonPlayerCharacters);
FmbUtil.WriteObject(writer, obj.Paths);
writer.Write(obj.Descending);
writer.Write(obj.Rainy);
writer.Write(obj.LowPass);
FmbUtil.WriteObject(writer, obj.MutedLoops);
FmbUtil.WriteObject(writer, obj.AmbienceTracks);
FmbUtil.WriteObject(writer, obj.NodeType);
writer.Write(obj.Quantum);
}
public override object Read(BinaryReader reader, bool xnb)
{
Level obj = new Level();
obj.Name = FmbUtil.ReadObject <string>(reader, xnb);
obj.Size = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.StartingPosition = FmbUtil.ReadObject <TrileFace>(reader, xnb);
obj.SequenceSamplesPath = FmbUtil.ReadObject <string>(reader, xnb);
FmbHelper.Log("debug: Level: SequenceSamplesPath: " + obj.SequenceSamplesPath);
obj.Flat = reader.ReadBoolean();
obj.SkipPostProcess = reader.ReadBoolean();
obj.BaseDiffuse = reader.ReadSingle();
obj.BaseAmbient = reader.ReadSingle();
obj.GomezHaloName = FmbUtil.ReadObject <string>(reader, xnb);
obj.HaloFiltering = reader.ReadBoolean();
obj.BlinkingAlpha = reader.ReadBoolean();
obj.Loops = reader.ReadBoolean();
obj.WaterType = FmbUtil.ReadObject <LiquidType>(reader, xnb);
obj.WaterHeight = reader.ReadSingle();
obj.SkyName = reader.ReadString();
obj.TrileSetName = FmbUtil.ReadObject <string>(reader, xnb);
obj.Volumes = FmbUtil.ReadObject <Dictionary <int, Volume> >(reader, xnb);
obj.Scripts = FmbUtil.ReadObject <Dictionary <int, Script> >(reader, xnb);
obj.SongName = FmbUtil.ReadObject <string>(reader, xnb);
obj.FAPFadeOutStart = reader.ReadInt32();
obj.FAPFadeOutLength = reader.ReadInt32();
obj.Triles = FmbUtil.ReadObject <Dictionary <TrileEmplacement, TrileInstance> >(reader, xnb);
obj.ArtObjects = FmbUtil.ReadObject <Dictionary <int, ArtObjectInstance> >(reader, xnb);
obj.BackgroundPlanes = FmbUtil.ReadObject <Dictionary <int, BackgroundPlane> >(reader, xnb);
obj.Groups = FmbUtil.ReadObject <Dictionary <int, TrileGroup> >(reader, xnb);
obj.NonPlayerCharacters = FmbUtil.ReadObject <Dictionary <int, NpcInstance> >(reader, xnb);
obj.Paths = FmbUtil.ReadObject <Dictionary <int, MovementPath> >(reader, xnb);
obj.Descending = reader.ReadBoolean();
obj.Rainy = reader.ReadBoolean();
obj.LowPass = reader.ReadBoolean();
obj.MutedLoops = FmbUtil.ReadObject <List <string> >(reader, xnb);
obj.AmbienceTracks = FmbUtil.ReadObject <List <AmbienceTrack> >(reader, xnb);
obj.NodeType = FmbUtil.ReadObject <LevelNodeType>(reader, xnb);
obj.Quantum = reader.ReadBoolean();
obj.OnDeserialization();
return(obj);
}
public override void Write(BinaryWriter writer, object obj_)
{
ArtObjectActorSettings obj = (ArtObjectActorSettings)obj_;
writer.Write(obj.Inactive);
FmbUtil.WriteObject(writer, obj.ContainedTrile);
FmbUtil.WriteObject(writer, obj.AttachedGroup);
FmbUtil.WriteObject(writer, obj.SpinView);
writer.Write(obj.SpinEvery);
writer.Write(obj.SpinOffset);
writer.Write(obj.OffCenter);
FmbUtil.GetTypeHandler <Vector3>().Write(writer, obj.RotationCenter);
FmbUtil.WriteObject(writer, obj.VibrationPattern);
FmbUtil.WriteObject(writer, obj.CodePattern);
FmbUtil.WriteObject(writer, obj.Segment);
FmbUtil.WriteObject(writer, obj.NextNode);
FmbUtil.WriteObject(writer, obj.DestinationLevel);
FmbUtil.WriteObject(writer, obj.TreasureMapName);
FmbUtil.WriteObject(writer, FmbHelper.HashSetOrListToArray <FaceOrientation>(obj.InvisibleSides));
writer.Write(obj.TimeswitchWindBackSpeed);
}
public override object Read(BinaryReader reader, bool xnb)
{
ArtObjectActorSettings obj = new ArtObjectActorSettings();
obj.Inactive = reader.ReadBoolean();
obj.ContainedTrile = FmbUtil.ReadObject <ActorType>(reader, xnb);
obj.AttachedGroup = FmbUtil.ReadObject <int?>(reader, xnb);
obj.SpinView = FmbUtil.ReadObject <Viewpoint>(reader, xnb);
obj.SpinEvery = reader.ReadSingle();
obj.SpinOffset = reader.ReadSingle();
obj.OffCenter = reader.ReadBoolean();
obj.RotationCenter = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.VibrationPattern = FmbUtil.ReadObject <VibrationMotor[]>(reader, xnb);
obj.CodePattern = FmbUtil.ReadObject <CodeInput[]>(reader, xnb);
obj.Segment = FmbUtil.ReadObject <PathSegment>(reader, xnb);
obj.NextNode = FmbUtil.ReadObject <int?>(reader, xnb);
obj.DestinationLevel = FmbUtil.ReadObject <string>(reader, xnb);
obj.TreasureMapName = FmbUtil.ReadObject <string>(reader, xnb);
obj.InvisibleSides = FmbHelper.HashSetOrList <FaceOrientation>(FmbUtil.ReadObject <FaceOrientation[]>(reader, xnb), FaceOrientationComparer.Default);
obj.TimeswitchWindBackSpeed = reader.ReadSingle();
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
if (!xnb)
{
FmbHelper.Log("Reading Texture2Ds will not be implemented - use external images and read / write manually!");
reader.ReadInt32(); //surfaceFormat
reader.ReadInt32(); //width
reader.ReadInt32(); //height
reader.ReadInt32(); //mips
//reader.ReadInt32(); //data length
return(null);
}
//After I've got feedback from Rioku, we're reading the texture data but (currently) not saving it.
bool readTexture;
#if XNA
//XNA requires a graphics device. One should be supplied via FmbUtil.Setup.GraphicsDevice if wanted.
readTexture = FmbUtil.Setup.GraphicsDevice != null;
#elif UNITY
//Unity doesn't need a graphics device and can always read the texture.
readTexture = true;
#else
//XnaSlim will never read internal textures as such. They may return the data in some texture container format, though.
readTexture = false;
#endif
if (!readTexture || FmbUtil.IsTEST)
{
reader.ReadInt32(); //surfaceFormat
reader.ReadInt32(); //width
reader.ReadInt32(); //height
int mips = reader.ReadInt32();
for (int i = 0; i < mips; i++)
{
int dataSize = reader.ReadInt32();
reader.BaseStream.Seek(dataSize, SeekOrigin.Current);
}
return(null);
}
SurfaceFormat surfaceFormat = (SurfaceFormat)reader.ReadInt32();
int width = reader.ReadInt32();
int height = reader.ReadInt32();
int levels = reader.ReadInt32();
//Let's pretend we don't know about DXT1, S3TC nor the other formats to convert.
Texture2D texture = GenTexture(width, height, surfaceFormat, levels);
#if XNA
//For XNA, we simply iterate through all levels and set the level data.
for (int i = 0; i < levels; i++)
{
int levelSize = reader.ReadInt32();
texture.SetData(i, null, reader.ReadBytes(levelSize), 0, levelSize);
}
#elif UNITY
//Oh, Unity, why do we need to merge all levels into a single blob? RIP loading time.
if (levels == 1)
{
texture.LoadRawTextureData(Remap(reader.ReadBytes(reader.ReadInt32()), surfaceFormat));
}
else
{
int dataSize = 0;
byte[][] levelDatas = new byte[levels][];
for (int i = 0; i < levels; i++)
{
int levelSize = reader.ReadInt32();
dataSize += levelSize;
levelDatas[i] = Remap(reader.ReadBytes(levelSize), surfaceFormat);
}
byte[] data = new byte[dataSize];
int offs = 0;
for (int i = 0; i < levels; i++)
{
byte[] levelData = levelDatas[i];
Array.Copy(levelData, 0, data, offs, levelData.Length);
}
}
//updateMipmaps is true by default; makeNoLongerReadable should be false.
texture.Apply(false, FmbUtil.Setup.TexturesWriteOnly);
#endif
return(texture);
}
