System.IO.BinaryReader.ReadInt16()

Here are the examples of the csharp api System.IO.BinaryReader.ReadInt16() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

759 Examples 7

19 Source : Wire.cs
with Apache License 2.0
from danielcrenna

private static object ReadValue(this Type type, BinaryReader br, ITypeResolver typeResolver)
		{
			while (true)
			{
				readValue:

				if (type == null)
					throw new NullReferenceException();

				if (type == typeof(string))
					return br.ReadIsNull() ? default : br.ReadString();
				if (type == typeof(bool))
					return BuiltIns.ReadBoolean(br);
				if (type == typeof(int))
					return br.ReadInt32();
				if (type == typeof(long))
					return br.ReadInt64();
				if (type == typeof(float))
					return br.ReadSingle();
				if (type == typeof(double))
					return br.ReadDouble();
				if (type == typeof(decimal))
					return br.ReadDecimal();
				if (type == typeof(short))
					return br.ReadInt16();
				if (type == typeof(uint))
					return br.ReadUInt32();
				if (type == typeof(ulong))
					return br.ReadUInt64();
				if (type == typeof(ushort))
					return br.ReadUInt16();
				if (type == typeof(byte))
					return br.ReadByte();
				if (type == typeof(sbyte))
					return br.ReadSByte();
				if (type == typeof(char))
					return br.ReadChar();

				if (type == typeof(byte?))
					return br.ReadIsNull() ? default : br.ReadByte();
				if (type == typeof(sbyte?))
					return br.ReadIsNull() ? default : br.ReadSByte();
				if (type == typeof(bool?))
					return br.ReadIsNull() ? default : br.ReadBoolean();
				if (type == typeof(short?))
					return br.ReadIsNull() ? default : br.ReadInt16();
				if (type == typeof(ushort?))
					return br.ReadIsNull() ? default : br.ReadUInt16();
				if (type == typeof(int?))
					return br.ReadIsNull() ? default : br.ReadInt32();
				if (type == typeof(uint?))
					return br.ReadIsNull() ? default : br.ReadUInt32();
				if (type == typeof(long?))
					return br.ReadIsNull() ? default : br.ReadInt64();
				if (type == typeof(ulong?))
					return br.ReadIsNull() ? default : br.ReadUInt64();
				if (type == typeof(float?))
					return br.ReadIsNull() ? default : br.ReadSingle();
				if (type == typeof(double?))
					return br.ReadIsNull() ? default : br.ReadDouble();
				if (type == typeof(decimal?))
					return br.ReadIsNull() ? default : br.ReadDecimal();
				if (type == typeof(char?))
					return br.ReadIsNull() ? default : br.ReadChar();

				if (type == typeof(char[]))
					return br.ReadIsNull() ? null : ReadCharArray(br);
				if (type == typeof(byte[]))
					return br.ReadIsNull() ? null : ReadByteArray(br);

				if (type == typeof(TimeSpan))
					return br.ReadTimeSpan();
				if (type == typeof(DateTimeOffset))
					return br.ReadDateTimeOffset();
				if (type == typeof(DateTime))
					return br.ReadDateTime(typeResolver);

				if (type == typeof(TimeSpan?))
					return br.ReadIsNull() ? default : br.ReadTimeSpan();
				if (type == typeof(DateTimeOffset?))
					return br.ReadIsNull() ? null : br.ReadDateTimeOffset();
				if (type == typeof(DateTime?))
					return br.ReadIsNull() ? null : ReadDateTime(br, typeResolver);

				if (typeof(IDictionary<,>).IsreplacedignableFromGeneric(type))
				{
					if (br.ReadIsNull())
						return null;

					var method = ReadTypedDictionaryMethod;
					if (method == null)
						throw new NullReferenceException();

					var genericMethod = method.MakeGenericMethod(type.GenericTypeArguments);
					return genericMethod.Invoke(null, new object [] { br, typeResolver });
				}

				if (typeof(IList<>).IsreplacedignableFromGeneric(type))
					return br.ReadIsNull() ? null : br.ReadTypedList(type, typeResolver);
				
				if (typeof(IList).IsreplacedignableFrom(type))
					return br.ReadIsNull() ? null : br.ReadList(type, typeResolver);

				if (type.IsEnum)
				{
					type = GetEnumType(type);
					goto readValue;
				}

				if (Nullable.GetUnderlyingType(type) != null)
				{
					if (!br.ReadIsNull())
					{
						type = Nullable.GetUnderlyingType(type);
						goto readValue;
					}

					return null;
				}

				return br.ReadObject(type, typeResolver);
			}
		}

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TRRoomPortal ReadRoomPortal(BinaryReader reader)
        {
            return new TRRoomPortal
            {
                AdjoiningRoom = reader.ReadUInt16(),

                Normal = new TRVertex
                {
                    X = reader.ReadInt16(),
                    Y = reader.ReadInt16(),
                    Z = reader.ReadInt16()
                },

                Vertices = new TRVertex[]
                {
                    new TRVertex { X = reader.ReadInt16(), Y = reader.ReadInt16(), Z = reader.ReadInt16() },
                    new TRVertex { X = reader.ReadInt16(), Y = reader.ReadInt16(), Z = reader.ReadInt16() },
                    new TRVertex { X = reader.ReadInt16(), Y = reader.ReadInt16(), Z = reader.ReadInt16() },
                    new TRVertex { X = reader.ReadInt16(), Y = reader.ReadInt16(), Z = reader.ReadInt16() },
                }
            };
        }

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TRAnimation ReadAnimation(BinaryReader reader)
        {
            return new TRAnimation
            {
                FrameOffset = reader.ReadUInt32(),
                FrameRate = reader.ReadByte(),
                FrameSize = reader.ReadByte(),
                StateID = reader.ReadUInt16(),
                Speed = new FixedFloat32
                {
                    Whole = reader.ReadInt16(),
                    Fraction = reader.ReadUInt16()
                },
                Accel = new FixedFloat32
                {
                    Whole = reader.ReadInt16(),
                    Fraction = reader.ReadUInt16()
                },
                FrameStart = reader.ReadUInt16(),
                FrameEnd = reader.ReadUInt16(),
                NextAnimation = reader.ReadUInt16(),
                NextFrame = reader.ReadUInt16(),
                NumStateChanges = reader.ReadUInt16(),
                StateChangeOffset = reader.ReadUInt16(),
                NumAnimCommands = reader.ReadUInt16(),
                AnimCommand = reader.ReadUInt16()
            };
        }

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TRAnimDispatch ReadAnimDispatch(BinaryReader reader)
        {
            return new TRAnimDispatch()
            {
                Low = reader.ReadInt16(),
                High = reader.ReadInt16(),
                NextAnimation = reader.ReadInt16(),
                NextFrame = reader.ReadInt16()
            };
        }

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TRVertex ReadVertex(BinaryReader reader)
        {
            return new TRVertex
            {
                X = reader.ReadInt16(),
                Y = reader.ReadInt16(),
                Z = reader.ReadInt16()
            };
        }

19 Source : TR2LevelReader.cs
with MIT License
from DanzaG

public TR2Level ReadLevel(string Filename)
        {
            if (!Filename.ToUpper().Contains("TR2"))
            {
                throw new NotImplementedException("File reader only supports TR2 levels");
            }

            TR2Level level = new TR2Level();
            reader = new BinaryReader(File.Open(Filename, FileMode.Open));

            //Version
            level.Version = reader.ReadUInt32();
            if (level.Version != Versions.TR2)
            {
                throw new NotImplementedException("File reader only suppors TR2 levels");
            }

            //Colour palettes and textures
            level.Palette = PopulateColourPalette(reader.ReadBytes((int)MAX_PALETTE_SIZE * 3));

            level.Palette16 = PopulateColourPalette16(reader.ReadBytes((int)MAX_PALETTE_SIZE * 4));

            level.NumImages = reader.ReadUInt32();

            level.Images8 = new TRTexImage8[level.NumImages];
            level.Images16 = new TRTexImage16[level.NumImages];

            //Initialize the texture arrays
            for (int i = 0; i < level.NumImages; i++)
            {
                level.Images8[i] = new TRTexImage8();
                level.Images16[i] = new TRTexImage16();
            }

            //For each texture8 there are 256 * 256 bytes (65536) we can just do a straight byte read
            for (int i = 0; i < level.NumImages; i++)
            {
                level.Images8[i].Pixels = reader.ReadBytes(256 * 256);
            }

            //For each texture16 there are 256 * 256 * 2 bytes (131072)
            for (int i = 0; i < level.NumImages; i++)
            {
                level.Images16[i].Pixels = new ushort[256 * 256];

                for (int j = 0; j < level.Images16[i].Pixels.Count(); j++)
                {
                    level.Images16[i].Pixels[j] = reader.ReadUInt16();
                }
            }

            //Rooms
            level.Unused = reader.ReadUInt32();
            level.NumRooms = reader.ReadUInt16();
            level.Rooms = new TR2Room[level.NumRooms];

            for (int i = 0; i < level.NumRooms; i++)
            {
                TR2Room room = new TR2Room();

                //Grab info
                room.Info = new TRRoomInfo
                {
                    X = reader.ReadInt32(),
                    Z = reader.ReadInt32(),
                    YBottom = reader.ReadInt32(),
                    YTop = reader.ReadInt32()
                };

                //Grab data
                room.NumDataWords = reader.ReadUInt32();
                room.Data = new ushort[room.NumDataWords];
                for (int j = 0; j < room.NumDataWords; j++)
                {
                    room.Data[j] = reader.ReadUInt16();
                }

                //Store what we just read
                room.RoomData = ConvertToRoomData(room);

                //Portals
                room.NumPortals = reader.ReadUInt16();
                room.Portals = new TRRoomPortal[room.NumPortals];
                for (int j = 0; j < room.NumPortals; j++)
                {
                    room.Portals[j] = TR2FileReadUtilities.ReadRoomPortal(reader);
                }

                //Sectors
                room.NumZSectors = reader.ReadUInt16();
                room.NumXSectors = reader.ReadUInt16();
                room.SectorList = new TRRoomSector[room.NumXSectors * room.NumZSectors];
                for (int j = 0; j < (room.NumXSectors * room.NumZSectors); j++)
                {
                    room.SectorList[j] = TR2FileReadUtilities.ReadRoomSector(reader);
                }

                //Lighting
                room.AmbientIntensity = reader.ReadInt16();
                room.AmbientIntensity2 = reader.ReadInt16();
                room.LightMode = reader.ReadInt16();
                room.NumLights = reader.ReadUInt16();
                room.Lights = new TR2RoomLight[room.NumLights];
                for (int j = 0; j < room.NumLights; j++)
                {
                    room.Lights[j] = TR2FileReadUtilities.ReadRoomLight(reader);
                }

                //Static meshes
                room.NumStaticMeshes = reader.ReadUInt16();
                room.StaticMeshes = new TR2RoomStaticMesh[room.NumStaticMeshes];
                for (int j = 0; j < room.NumStaticMeshes; j++)
                {
                    room.StaticMeshes[j] = TR2FileReadUtilities.ReadRoomStaticMesh(reader);
                }

                room.AlternateRoom = reader.ReadInt16();
                room.Flags = reader.ReadInt16();

                level.Rooms[i] = room;
            }

            //Floordata
            level.NumFloorData = reader.ReadUInt32();
            level.FloorData = new ushort[level.NumFloorData];

            for (int i = 0; i < level.NumFloorData; i++)
            {
                level.FloorData[i] = reader.ReadUInt16();
            }

            //Mesh Data
            //This tells us how much mesh data (# of words/uint16s) coming up
            //just like the rooms previously.
            level.NumMeshData = reader.ReadUInt32();
            level.RawMeshData = new ushort[level.NumMeshData];

            for (int i = 0; i < level.NumMeshData; i++)
            {
                level.RawMeshData[i] = reader.ReadUInt16();
            }

            //Mesh Pointers
            level.NumMeshPointers = reader.ReadUInt32();
            level.MeshPointers = new uint[level.NumMeshPointers];

            for (int i = 0; i < level.NumMeshPointers; i++)
            {
                level.MeshPointers[i] = reader.ReadUInt32();
            }

            //Mesh Construction
            //level.Meshes = ConstructMeshData(level.NumMeshData, level.NumMeshPointers, level.RawMeshData);
            level.Meshes = ConstructMeshData(level.MeshPointers, level.RawMeshData);

            //Animations
            level.NumAnimations = reader.ReadUInt32();
            level.Animations = new TRAnimation[level.NumAnimations];
            for (int i = 0; i < level.NumAnimations; i++)
            {
                level.Animations[i] = TR2FileReadUtilities.ReadAnimation(reader);
            }

            //State Changes
            level.NumStateChanges = reader.ReadUInt32();
            level.StateChanges = new TRStateChange[level.NumStateChanges];
            for (int i = 0; i < level.NumStateChanges; i++)
            {
                level.StateChanges[i] = TR2FileReadUtilities.ReadStateChange(reader);
            }

            //Animation Dispatches
            level.NumAnimDispatches = reader.ReadUInt32();
            level.AnimDispatches = new TRAnimDispatch[level.NumAnimDispatches];
            for (int i = 0; i < level.NumAnimDispatches; i++)
            {
                level.AnimDispatches[i] = TR2FileReadUtilities.ReadAnimDispatch(reader);
            }

            //Animation Commands
            level.NumAnimCommands = reader.ReadUInt32();
            level.AnimCommands = new TRAnimCommand[level.NumAnimCommands];
            for (int i = 0; i < level.NumAnimCommands; i++)
            {
                level.AnimCommands[i] = TR2FileReadUtilities.ReadAnimCommand(reader);
            }

            //Mesh Trees
            level.NumMeshTrees = reader.ReadUInt32();
            level.NumMeshTrees /= 4;
            level.MeshTrees = new TRMeshTreeNode[level.NumMeshTrees];
            for (int i = 0; i < level.NumMeshTrees; i++)
            {
                level.MeshTrees[i] = TR2FileReadUtilities.ReadMeshTreeNode(reader);
            }

            //Frames
            level.NumFrames = reader.ReadUInt32();
            level.Frames = new ushort[level.NumFrames];
            for (int i = 0; i < level.NumFrames; i++)
            {
                level.Frames[i] = reader.ReadUInt16();
            }

            //Models
            level.NumModels = reader.ReadUInt32();
            level.Models = new TRModel[level.NumModels];

            for (int i = 0; i < level.NumModels; i++)
            {
                level.Models[i] = TR2FileReadUtilities.ReadModel(reader);
            }

            //Static Meshes
            level.NumStaticMeshes = reader.ReadUInt32();
            level.StaticMeshes = new TRStaticMesh[level.NumStaticMeshes];

            for (int i = 0; i < level.NumStaticMeshes; i++)
            {
                level.StaticMeshes[i] = TR2FileReadUtilities.ReadStaticMesh(reader);
            }

            //Object Textures
            level.NumObjectTextures = reader.ReadUInt32();
            level.ObjectTextures = new TRObjectTexture[level.NumObjectTextures];

            for (int i = 0; i < level.NumObjectTextures; i++)
            {
                level.ObjectTextures[i] = TR2FileReadUtilities.ReadObjectTexture(reader);
            }

            //Sprite Textures
            level.NumSpriteTextures = reader.ReadUInt32();
            level.SpriteTextures = new TRSpriteTexture[level.NumSpriteTextures];

            for (int i = 0; i < level.NumSpriteTextures; i++)
            {
                level.SpriteTextures[i] = TR2FileReadUtilities.ReadSpriteTexture(reader);
            }

            //Sprite Sequences
            level.NumSpriteSequences = reader.ReadUInt32();
            level.SpriteSequences = new TRSpriteSequence[level.NumSpriteSequences];

            for (int i = 0; i < level.NumSpriteSequences; i++)
            {
                level.SpriteSequences[i] = TR2FileReadUtilities.ReadSpriteSequence(reader);
            }

            //Cameras
            level.NumCameras = reader.ReadUInt32();
            level.Cameras = new TRCamera[level.NumCameras];

            for (int i = 0; i < level.NumCameras; i++)
            {
                level.Cameras[i] = TR2FileReadUtilities.ReadCamera(reader);
            }

            //Sound Sources
            level.NumSoundSources = reader.ReadUInt32();
            level.SoundSources = new TRSoundSource[level.NumSoundSources];

            for (int i = 0; i < level.NumSoundSources; i++)
            {
                level.SoundSources[i] = TR2FileReadUtilities.ReadSoundSource(reader);
            }

            //Boxes
            level.NumBoxes = reader.ReadUInt32();
            level.Boxes = new TR2Box[level.NumBoxes];

            for (int i = 0; i < level.NumBoxes; i++)
            {
                level.Boxes[i] = TR2FileReadUtilities.ReadBox(reader);
            }

            //Overlaps & Zones
            level.NumOverlaps = reader.ReadUInt32();
            level.Overlaps = new ushort[level.NumOverlaps];

            for (int i = 0; i < level.NumOverlaps; i++)
            {
                level.Overlaps[i] = reader.ReadUInt16();
            }

            // Although TRosettaStone references a struct for zones, the data isn't
            // sequential. Instead it's organised by flipmap status, all the groundzone
            // values are then together and the flyzones at the end. TR2BoxUtilities
            // handles the complexity here, so we just preplaced the raw ushort values.
            ushort[] zoneData = new ushort[level.NumBoxes * 10];
            for (int i = 0; i < zoneData.Length; i++)
            {
                zoneData[i] = reader.ReadUInt16();
            }
            level.Zones = TR2BoxUtilities.ReadZones(level.NumBoxes, zoneData);

            //Animated Textures - the data stores the total number of ushorts to read (NumAnimatedTextures)
            //followed by a ushort to describe the number of actual texture group objects.
            level.NumAnimatedTextures = reader.ReadUInt32();
            level.AnimatedTextures = new TRAnimatedTexture[reader.ReadUInt16()];
            for (int i = 0; i < level.AnimatedTextures.Length; i++)
            {
                level.AnimatedTextures[i] = TR2FileReadUtilities.ReadAnimatedTexture(reader);
            }

            //Enreplacedies
            level.NumEnreplacedies = reader.ReadUInt32();
            level.Enreplacedies = new TR2Enreplacedy[level.NumEnreplacedies];

            for (int i = 0; i < level.NumEnreplacedies; i++)
            {
                level.Enreplacedies[i] = TR2FileReadUtilities.ReadEnreplacedy(reader);
            }

            //Light Map - 32 * 256 = 8192 bytes
            level.LightMap = new byte[32 * 256];

            for (int i = 0; i < level.LightMap.Count(); i++)
            {
                level.LightMap[i] = reader.ReadByte();
            }

            //Cinematic Frames
            level.NumCinematicFrames = reader.ReadUInt16();
            level.CinematicFrames = new TRCinematicFrame[level.NumCinematicFrames];

            for (int i = 0; i < level.NumCinematicFrames; i++)
            {
                level.CinematicFrames[i] = TR2FileReadUtilities.ReadCinematicFrame(reader);
            }

            //Demo Data
            level.NumDemoData = reader.ReadUInt16();
            level.DemoData = new byte[level.NumDemoData];

            for (int i = 0; i < level.NumDemoData; i++)
            {
                level.DemoData[i] = reader.ReadByte();
            }

            //Sound Map (370 shorts = 740 bytes) & Sound Details
            level.SoundMap = new short[370];

            for (int i = 0; i < level.SoundMap.Count(); i++)
            {
                level.SoundMap[i] = reader.ReadInt16();
            }

            level.NumSoundDetails = reader.ReadUInt32();
            level.SoundDetails = new TRSoundDetails[level.NumSoundDetails];

            for (int i = 0; i < level.NumSoundDetails; i++)
            {
                level.SoundDetails[i] = TR2FileReadUtilities.ReadSoundDetails(reader);
            }

            //Samples
            level.NumSampleIndices = reader.ReadUInt32();
            level.SampleIndices = new uint[level.NumSampleIndices];

            for (int i = 0; i < level.NumSampleIndices; i++)
            {
                level.SampleIndices[i] = reader.ReadUInt32();
            }

            Debug.replacedert(reader.BaseStream.Position == reader.BaseStream.Length);

            reader.Close();

            return level;
        }

19 Source : TR2LevelReader.cs
with MIT License
from DanzaG

private TRMesh[] ConstructMeshData(uint[] meshPointers, ushort[] rawMeshData)
        {
            byte[] target = new byte[rawMeshData.Length * 2];
            Buffer.BlockCopy(rawMeshData, 0, target, 0, target.Length);

            // The mesh pointer list can contain duplicates so we must make
            // sure to iterate over distinct values only
            meshPointers = meshPointers.Distinct().ToArray();

            List<TRMesh> meshes = new List<TRMesh>();

            using (MemoryStream ms = new MemoryStream(target))
            using (BinaryReader br = new BinaryReader(ms))
            {
                for (int i = 0; i < meshPointers.Length; i++)
                {
                    TRMesh mesh = new TRMesh();
                    meshes.Add(mesh);

                    uint meshPointer = meshPointers[i];         
                    br.BaseStream.Position = meshPointer;

                    //Pointer
                    mesh.Pointer = meshPointer;

                    //Centre
                    mesh.Centre = TR2FileReadUtilities.ReadVertex(br);

                    //CollRadius
                    mesh.CollRadius = br.ReadInt32();

                    //Vertices
                    mesh.NumVertices = br.ReadInt16();
                    mesh.Vertices = new TRVertex[mesh.NumVertices];
                    for (int j = 0; j < mesh.NumVertices; j++)
                    {
                        mesh.Vertices[j] = TR2FileReadUtilities.ReadVertex(br);
                    }

                    //Lights or Normals
                    mesh.NumNormals = br.ReadInt16();
                    if (mesh.NumNormals > 0)
                    {
                        mesh.Normals = new TRVertex[mesh.NumNormals];
                        for (int j = 0; j < mesh.NumNormals; j++)
                        {
                            mesh.Normals[j] = TR2FileReadUtilities.ReadVertex(br);
                        }
                    }
                    else
                    {
                        mesh.Lights = new short[Math.Abs(mesh.NumNormals)];
                        for (int j = 0; j < mesh.Lights.Length; j++)
                        {
                            mesh.Lights[j] = br.ReadInt16();
                        }
                    }

                    //Textured Rectangles
                    mesh.NumTexturedRectangles = br.ReadInt16();
                    mesh.TexturedRectangles = new TRFace4[mesh.NumTexturedRectangles];
                    for (int j = 0; j < mesh.NumTexturedRectangles; j++)
                    {
                        mesh.TexturedRectangles[j] = TR2FileReadUtilities.ReadTRFace4(br);
                    }

                    //Textured Triangles
                    mesh.NumTexturedTriangles = br.ReadInt16();
                    mesh.TexturedTriangles = new TRFace3[mesh.NumTexturedTriangles];
                    for (int j = 0; j < mesh.NumTexturedTriangles; j++)
                    {
                        mesh.TexturedTriangles[j] = TR2FileReadUtilities.ReadTRFace3(br);
                    }

                    //Coloured Rectangles
                    mesh.NumColouredRectangles = br.ReadInt16();
                    mesh.ColouredRectangles = new TRFace4[mesh.NumColouredRectangles];
                    for (int j = 0; j < mesh.NumColouredRectangles; j++)
                    {
                        mesh.ColouredRectangles[j] = TR2FileReadUtilities.ReadTRFace4(br);
                    }

                    //Coloured Triangles
                    mesh.NumColouredTriangles = br.ReadInt16();
                    mesh.ColouredTriangles = new TRFace3[mesh.NumColouredTriangles];
                    for (int j = 0; j < mesh.NumColouredTriangles; j++)
                    {
                        mesh.ColouredTriangles[j] = TR2FileReadUtilities.ReadTRFace3(br);
                    }

                    // There may be alignment padding at the end of the mesh, but rather than
                    // storing it, when the mesh is serialized the alignment should be considered.
                    // It seems to be 4-byte alignment for mesh data. The basestream position is
                    // moved to the next pointer in the next iteration, so we don't need to process
                    // the additional data here.
                    // See https://www.tombraiderforums.com/archive/index.php/t-215247.html
                }
            }

            return meshes.ToArray();
        }

19 Source : TR3FileReadUtilities.cs
with MIT License
from DanzaG

public static TR3RoomLight ReadRoomLight(BinaryReader reader)
        {
            return new TR3RoomLight
            {
                X = reader.ReadInt32(),
                Y = reader.ReadInt32(),
                Z = reader.ReadInt32(),
                Colour = new TRColour
                {
                    Red = reader.ReadByte(),
                    Green = reader.ReadByte(),
                    Blue = reader.ReadByte()
                },
                LightType = reader.ReadByte(),
                LightProperties = new short[4]
                {
                    reader.ReadInt16(),
                    reader.ReadInt16(),
                    reader.ReadInt16(),
                    reader.ReadInt16()
                }
            };
        }

19 Source : TR3FileReadUtilities.cs
with MIT License
from DanzaG

public static TR3SoundDetails ReadSoundDetails(BinaryReader reader)
        {
            return new TR3SoundDetails()
            {
                Sample = reader.ReadUInt16(),
                Volume = reader.ReadByte(),
                Range = reader.ReadByte(),
                Chance = reader.ReadByte(),
                Pitch = reader.ReadByte(),
                Characteristics = reader.ReadInt16()
            };
        }

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TRStaticMesh ReadStaticMesh(BinaryReader reader)
        {
            return new TRStaticMesh()
            {
                ID = reader.ReadUInt32(),
                Mesh = reader.ReadUInt16(),
                VisibilityBox = new TRBoundingBox
                {
                    MinX = reader.ReadInt16(),
                    MaxX = reader.ReadInt16(),
                    MinY = reader.ReadInt16(),
                    MaxY = reader.ReadInt16(),
                    MinZ = reader.ReadInt16(),
                    MaxZ = reader.ReadInt16()
                },
                CollisionBox = new TRBoundingBox
                {
                    MinX = reader.ReadInt16(),
                    MaxX = reader.ReadInt16(),
                    MinY = reader.ReadInt16(),
                    MaxY = reader.ReadInt16(),
                    MinZ = reader.ReadInt16(),
                    MaxZ = reader.ReadInt16()
                },
                Flags = reader.ReadUInt16()
            };
        }

19 Source : TR3LevelReader.cs
with MIT License
from DanzaG

public TR3Level ReadLevel(string Filename)
        {
            if (!Filename.ToUpper().Contains("TR2"))
            {
                throw new NotImplementedException("File reader only supports TR3 levels");
            }

            TR3Level level = new TR3Level();
            reader = new BinaryReader(File.Open(Filename, FileMode.Open));

            //Version
            level.Version = reader.ReadUInt32();
            if (level.Version != Versions.TR3a && level.Version != Versions.TR3b)
            {
                throw new NotImplementedException("File reader only suppors TR3 levels");
            }

            //Colour palettes and textures
            level.Palette = PopulateColourPalette(reader.ReadBytes((int)MAX_PALETTE_SIZE * 3));

            level.Palette16 = PopulateColourPalette16(reader.ReadBytes((int)MAX_PALETTE_SIZE * 4));

            level.NumImages = reader.ReadUInt32();

            level.Images8 = new TRTexImage8[level.NumImages];
            level.Images16 = new TRTexImage16[level.NumImages];

            //Initialize the texture arrays
            for (int i = 0; i < level.NumImages; i++)
            {
                level.Images8[i] = new TRTexImage8();
                level.Images16[i] = new TRTexImage16();
            }

            //For each texture8 there are 256 * 256 bytes (65536) we can just do a straight byte read
            for (int i = 0; i < level.NumImages; i++)
            {
                level.Images8[i].Pixels = reader.ReadBytes(256 * 256);
            }

            //For each texture16 there are 256 * 256 * 2 bytes (131072)
            for (int i = 0; i < level.NumImages; i++)
            {
                level.Images16[i].Pixels = new ushort[256 * 256];

                for (int j = 0; j < level.Images16[i].Pixels.Count(); j++)
                {
                    level.Images16[i].Pixels[j] = reader.ReadUInt16();
                }
            }

            //Rooms
            level.Unused = reader.ReadUInt32();
            level.NumRooms = reader.ReadUInt16();
            level.Rooms = new TR3Room[level.NumRooms];

            for (int i = 0; i < level.NumRooms; i++)
            {
                TR3Room room = new TR3Room();

                //Grab info
                room.Info = new TRRoomInfo
                {
                    X = reader.ReadInt32(),
                    Z = reader.ReadInt32(),
                    YBottom = reader.ReadInt32(),
                    YTop = reader.ReadInt32()
                };

                //Grab data
                room.NumDataWords = reader.ReadUInt32();
                room.Data = new ushort[room.NumDataWords];
                for (int j = 0; j < room.NumDataWords; j++)
                {
                    room.Data[j] = reader.ReadUInt16();
                }

                //Store what we just read
                room.RoomData = ConvertToRoomData(room);

                //Portals
                room.NumPortals = reader.ReadUInt16();
                room.Portals = new TRRoomPortal[room.NumPortals];
                for (int j = 0; j < room.NumPortals; j++)
                {
                    room.Portals[j] = TR2FileReadUtilities.ReadRoomPortal(reader);
                }

                //Sectors
                room.NumZSectors = reader.ReadUInt16();
                room.NumXSectors = reader.ReadUInt16();
                room.Sectors = new TRRoomSector[room.NumXSectors * room.NumZSectors];
                for (int j = 0; j < (room.NumXSectors * room.NumZSectors); j++)
                {
                    room.Sectors[j] = TR2FileReadUtilities.ReadRoomSector(reader);
                }

                //Lighting
                room.AmbientIntensity = reader.ReadInt16();
                room.LightMode = reader.ReadInt16();
                room.NumLights = reader.ReadUInt16();
                room.Lights = new TR3RoomLight[room.NumLights];
                for (int j = 0; j < room.NumLights; j++)
                {
                    room.Lights[j] = TR3FileReadUtilities.ReadRoomLight(reader);
                }

                //Static meshes
                room.NumStaticMeshes = reader.ReadUInt16();
                room.StaticMeshes = new TR3RoomStaticMesh[room.NumStaticMeshes];
                for (int j = 0; j < room.NumStaticMeshes; j++)
                {
                    room.StaticMeshes[j] = TR3FileReadUtilities.ReadRoomStaticMesh(reader);
                }

                room.AlternateRoom = reader.ReadInt16();
                room.Flags = reader.ReadInt16();

                //New TR3 room info
                room.WaterScheme = reader.ReadByte();
                room.ReverbInfo = reader.ReadByte();
                room.Filler = reader.ReadByte();

                level.Rooms[i] = room;
            }

            //Floordata
            level.NumFloorData = reader.ReadUInt32();
            level.FloorData = new ushort[level.NumFloorData];

            for (int i = 0; i < level.NumFloorData; i++)
            {
                level.FloorData[i] = reader.ReadUInt16();
            }

            //Mesh Data
            //This tells us how much mesh data (# of words/uint16s) coming up
            //just like the rooms previously.
            level.NumMeshData = reader.ReadUInt32();
            level.RawMeshData = new ushort[level.NumMeshData];

            for (int i = 0; i < level.NumMeshData; i++)
            {
                level.RawMeshData[i] = reader.ReadUInt16();
            }

            //Mesh Pointers
            level.NumMeshPointers = reader.ReadUInt32();
            level.MeshPointers = new uint[level.NumMeshPointers];

            for (int i = 0; i < level.NumMeshPointers; i++)
            {
                level.MeshPointers[i] = reader.ReadUInt32();
            }

            //Mesh Construction
            //level.Meshes = ConstructMeshData(level.NumMeshData, level.NumMeshPointers, level.RawMeshData);
            level.Meshes = ConstructMeshData(level.MeshPointers, level.RawMeshData);

            //Animations
            level.NumAnimations = reader.ReadUInt32();
            level.Animations = new TRAnimation[level.NumAnimations];
            for (int i = 0; i < level.NumAnimations; i++)
            {
                level.Animations[i] = TR2FileReadUtilities.ReadAnimation(reader);
            }

            //State Changes
            level.NumStateChanges = reader.ReadUInt32();
            level.StateChanges = new TRStateChange[level.NumStateChanges];
            for (int i = 0; i < level.NumStateChanges; i++)
            {
                level.StateChanges[i] = TR2FileReadUtilities.ReadStateChange(reader);
            }

            //Animation Dispatches
            level.NumAnimDispatches = reader.ReadUInt32();
            level.AnimDispatches = new TRAnimDispatch[level.NumAnimDispatches];
            for (int i = 0; i < level.NumAnimDispatches; i++)
            {
                level.AnimDispatches[i] = TR2FileReadUtilities.ReadAnimDispatch(reader);
            }

            //Animation Commands
            level.NumAnimCommands = reader.ReadUInt32();
            level.AnimCommands = new TRAnimCommand[level.NumAnimCommands];
            for (int i = 0; i < level.NumAnimCommands; i++)
            {
                level.AnimCommands[i] = TR2FileReadUtilities.ReadAnimCommand(reader);
            }

            //Mesh Trees
            level.NumMeshTrees = reader.ReadUInt32();
            level.NumMeshTrees /= 4;
            level.MeshTrees = new TRMeshTreeNode[level.NumMeshTrees];
            for (int i = 0; i < level.NumMeshTrees; i++)
            {
                level.MeshTrees[i] = TR2FileReadUtilities.ReadMeshTreeNode(reader);
            }

            //Frames
            level.NumFrames = reader.ReadUInt32();
            level.Frames = new ushort[level.NumFrames];
            for (int i = 0; i < level.NumFrames; i++)
            {
                level.Frames[i] = reader.ReadUInt16();
            }

            //Models
            level.NumModels = reader.ReadUInt32();
            level.Models = new TRModel[level.NumModels];

            for (int i = 0; i < level.NumModels; i++)
            {
                level.Models[i] = TR2FileReadUtilities.ReadModel(reader);
            }

            //Static Meshes
            level.NumStaticMeshes = reader.ReadUInt32();
            level.StaticMeshes = new TRStaticMesh[level.NumStaticMeshes];

            for (int i = 0; i < level.NumStaticMeshes; i++)
            {
                level.StaticMeshes[i] = TR2FileReadUtilities.ReadStaticMesh(reader);
            }

            //Object Textures - in TR3 this is now after animated textures

            //Sprite Textures
            level.NumSpriteTextures = reader.ReadUInt32();
            level.SpriteTextures = new TRSpriteTexture[level.NumSpriteTextures];

            for (int i = 0; i < level.NumSpriteTextures; i++)
            {
                level.SpriteTextures[i] = TR2FileReadUtilities.ReadSpriteTexture(reader);
            }

            //Sprite Sequences
            level.NumSpriteSequences = reader.ReadUInt32();
            level.SpriteSequences = new TRSpriteSequence[level.NumSpriteSequences];

            for (int i = 0; i < level.NumSpriteSequences; i++)
            {
                level.SpriteSequences[i] = TR2FileReadUtilities.ReadSpriteSequence(reader);
            }

            //Cameras
            level.NumCameras = reader.ReadUInt32();
            level.Cameras = new TRCamera[level.NumCameras];

            for (int i = 0; i < level.NumCameras; i++)
            {
                level.Cameras[i] = TR2FileReadUtilities.ReadCamera(reader);
            }

            //Sound Sources
            level.NumSoundSources = reader.ReadUInt32();
            level.SoundSources = new TRSoundSource[level.NumSoundSources];

            for (int i = 0; i < level.NumSoundSources; i++)
            {
                level.SoundSources[i] = TR2FileReadUtilities.ReadSoundSource(reader);
            }

            //Boxes
            level.NumBoxes = reader.ReadUInt32();
            level.Boxes = new TR2Box[level.NumBoxes];

            for (int i = 0; i < level.NumBoxes; i++)
            {
                level.Boxes[i] = TR2FileReadUtilities.ReadBox(reader);
            }

            //Overlaps & Zones
            level.NumOverlaps = reader.ReadUInt32();
            level.Overlaps = new ushort[level.NumOverlaps];

            for (int i = 0; i < level.NumOverlaps; i++)
            {
                level.Overlaps[i] = reader.ReadUInt16();
            }

            ushort[] zoneData = new ushort[level.NumBoxes * 10];
            for (int i = 0; i < zoneData.Length; i++)
            {
                zoneData[i] = reader.ReadUInt16();
            }
            level.Zones = TR2BoxUtilities.ReadZones(level.NumBoxes, zoneData);

            //Animated Textures - the data stores the total number of ushorts to read (NumAnimatedTextures)
            //followed by a ushort to describe the number of actual texture group objects.
            level.NumAnimatedTextures = reader.ReadUInt32();
            level.AnimatedTextures = new TRAnimatedTexture[reader.ReadUInt16()];
            for (int i = 0; i < level.AnimatedTextures.Length; i++)
            {
                level.AnimatedTextures[i] = TR2FileReadUtilities.ReadAnimatedTexture(reader);
            }

            //Object Textures - in TR3 this is now after animated textures
            level.NumObjectTextures = reader.ReadUInt32();
            level.ObjectTextures = new TRObjectTexture[level.NumObjectTextures];

            for (int i = 0; i < level.NumObjectTextures; i++)
            {
                level.ObjectTextures[i] = TR2FileReadUtilities.ReadObjectTexture(reader);
            }

            //Enreplacedies
            level.NumEnreplacedies = reader.ReadUInt32();
            level.Enreplacedies = new TR2Enreplacedy[level.NumEnreplacedies];

            for (int i = 0; i < level.NumEnreplacedies; i++)
            {
                level.Enreplacedies[i] = TR2FileReadUtilities.ReadEnreplacedy(reader);
            }

            //Light Map - 32 * 256 = 8192 bytes
            level.LightMap = new byte[32 * 256];

            for (int i = 0; i < level.LightMap.Count(); i++)
            {
                level.LightMap[i] = reader.ReadByte();
            }

            //Cinematic Frames
            level.NumCinematicFrames = reader.ReadUInt16();
            level.CinematicFrames = new TRCinematicFrame[level.NumCinematicFrames];

            for (int i = 0; i < level.NumCinematicFrames; i++)
            {
                level.CinematicFrames[i] = TR2FileReadUtilities.ReadCinematicFrame(reader);
            }

            //Demo Data
            level.NumDemoData = reader.ReadUInt16();
            level.DemoData = new byte[level.NumDemoData];

            for (int i = 0; i < level.NumDemoData; i++)
            {
                level.DemoData[i] = reader.ReadByte();
            }

            //Sound Map (370 shorts = 740 bytes) & Sound Details
            level.SoundMap = new short[370];

            for (int i = 0; i < level.SoundMap.Count(); i++)
            {
                level.SoundMap[i] = reader.ReadInt16();
            }

            level.NumSoundDetails = reader.ReadUInt32();
            level.SoundDetails = new TR3SoundDetails[level.NumSoundDetails];

            for (int i = 0; i < level.NumSoundDetails; i++)
            {
                level.SoundDetails[i] = TR3FileReadUtilities.ReadSoundDetails(reader);
            }

            //Samples
            level.NumSampleIndices = reader.ReadUInt32();
            level.SampleIndices = new uint[level.NumSampleIndices];

            for (int i = 0; i < level.NumSampleIndices; i++)
            {
                level.SampleIndices[i] = reader.ReadUInt32();
            }

            Debug.replacedert(reader.BaseStream.Position == reader.BaseStream.Length);

            reader.Close();

            return level;
        }

19 Source : TR3LevelReader.cs
with MIT License
from DanzaG

private TRMesh[] ConstructMeshData(uint[] meshPointers, ushort[] rawMeshData)
        {
            byte[] target = new byte[rawMeshData.Length * 2];
            Buffer.BlockCopy(rawMeshData, 0, target, 0, target.Length);

            // The mesh pointer list can contain duplicates so we must make
            // sure to iterate over distinct values only
            meshPointers = meshPointers.Distinct().ToArray();

            List<TRMesh> meshes = new List<TRMesh>();

            using (MemoryStream ms = new MemoryStream(target))
            using (BinaryReader br = new BinaryReader(ms))
            {
                for (int i = 0; i < meshPointers.Length; i++)
                {
                    TRMesh mesh = new TRMesh();
                    meshes.Add(mesh);

                    uint meshPointer = meshPointers[i];
                    br.BaseStream.Position = meshPointer;

                    //Pointer
                    mesh.Pointer = meshPointer;

                    //Centre
                    mesh.Centre = TR2FileReadUtilities.ReadVertex(br);

                    //CollRadius
                    mesh.CollRadius = br.ReadInt32();

                    //Vertices
                    mesh.NumVertices = br.ReadInt16();
                    mesh.Vertices = new TRVertex[mesh.NumVertices];
                    for (int j = 0; j < mesh.NumVertices; j++)
                    {
                        mesh.Vertices[j] = TR2FileReadUtilities.ReadVertex(br);
                    }

                    //Lights or Normals
                    mesh.NumNormals = br.ReadInt16();
                    if (mesh.NumNormals > 0)
                    {
                        mesh.Normals = new TRVertex[mesh.NumNormals];
                        for (int j = 0; j < mesh.NumNormals; j++)
                        {
                            mesh.Normals[j] = TR2FileReadUtilities.ReadVertex(br);
                        }
                    }
                    else
                    {
                        mesh.Lights = new short[Math.Abs(mesh.NumNormals)];
                        for (int j = 0; j < mesh.Lights.Length; j++)
                        {
                            mesh.Lights[j] = br.ReadInt16();
                        }
                    }

                    //Textured Rectangles
                    mesh.NumTexturedRectangles = br.ReadInt16();
                    mesh.TexturedRectangles = new TRFace4[mesh.NumTexturedRectangles];
                    for (int j = 0; j < mesh.NumTexturedRectangles; j++)
                    {
                        mesh.TexturedRectangles[j] = TR2FileReadUtilities.ReadTRFace4(br);
                    }

                    //Textured Triangles
                    mesh.NumTexturedTriangles = br.ReadInt16();
                    mesh.TexturedTriangles = new TRFace3[mesh.NumTexturedTriangles];
                    for (int j = 0; j < mesh.NumTexturedTriangles; j++)
                    {
                        mesh.TexturedTriangles[j] = TR2FileReadUtilities.ReadTRFace3(br);
                    }

                    //Coloured Rectangles
                    mesh.NumColouredRectangles = br.ReadInt16();
                    mesh.ColouredRectangles = new TRFace4[mesh.NumColouredRectangles];
                    for (int j = 0; j < mesh.NumColouredRectangles; j++)
                    {
                        mesh.ColouredRectangles[j] = TR2FileReadUtilities.ReadTRFace4(br);
                    }

                    //Coloured Triangles
                    mesh.NumColouredTriangles = br.ReadInt16();
                    mesh.ColouredTriangles = new TRFace3[mesh.NumColouredTriangles];
                    for (int j = 0; j < mesh.NumColouredTriangles; j++)
                    {
                        mesh.ColouredTriangles[j] = TR2FileReadUtilities.ReadTRFace3(br);
                    }

                    // There may be alignment padding at the end of the mesh, but rather than
                    // storing it, when the mesh is serialized the alignment should be considered.
                    // It seems to be 4-byte alignment for mesh data. The basestream position is
                    // moved to the next pointer in the next iteration, so we don't need to process
                    // the additional data here.
                    // See https://www.tombraiderforums.com/archive/index.php/t-215247.html
                }
            }

            return meshes.ToArray();
        }

19 Source : TR4FileReadUtilities.cs
with MIT License
from DanzaG

public static void PopulateDemoSoundSampleIndices(BinaryReader reader, TR4Level lvl)
        {
            //Demo Data
            lvl.LevelDataChunk.NumDemoData = reader.ReadUInt16();
            lvl.LevelDataChunk.DemoData = new byte[lvl.LevelDataChunk.NumDemoData];

            for (int i = 0; i < lvl.LevelDataChunk.NumDemoData; i++)
            {
                lvl.LevelDataChunk.DemoData[i] = reader.ReadByte();
            }

            //Sound Map (370 shorts) & Sound Details
            lvl.LevelDataChunk.SoundMap = new short[370];

            for (int i = 0; i < lvl.LevelDataChunk.SoundMap.Count(); i++)
            {
                lvl.LevelDataChunk.SoundMap[i] = reader.ReadInt16();
            }

            lvl.LevelDataChunk.NumSoundDetails = reader.ReadUInt32();
            lvl.LevelDataChunk.SoundDetails = new TR3SoundDetails[lvl.LevelDataChunk.NumSoundDetails];

            for (int i = 0; i < lvl.LevelDataChunk.NumSoundDetails; i++)
            {
                lvl.LevelDataChunk.SoundDetails[i] = TR3FileReadUtilities.ReadSoundDetails(reader);
            }

            //Samples
            lvl.LevelDataChunk.NumSampleIndices = reader.ReadUInt32();
            lvl.LevelDataChunk.SampleIndices = new uint[lvl.LevelDataChunk.NumSampleIndices];

            for (int i = 0; i < lvl.LevelDataChunk.NumSampleIndices; i++)
            {
                lvl.LevelDataChunk.SampleIndices[i] = reader.ReadUInt32();
            }
        }

19 Source : TR4FileReadUtilities.cs
with MIT License
from DanzaG

public static TR4Mesh[] ConstructMeshData(uint[] meshPointers, ushort[] rawMeshData)
        {
            byte[] target = new byte[rawMeshData.Length * 2];
            Buffer.BlockCopy(rawMeshData, 0, target, 0, target.Length);

            // The mesh pointer list can contain duplicates so we must make
            // sure to iterate over distinct values only
            meshPointers = meshPointers.Distinct().ToArray();

            List<TR4Mesh> meshes = new List<TR4Mesh>();

            using (MemoryStream ms = new MemoryStream(target))
            using (BinaryReader br = new BinaryReader(ms))
            {
                for (int i = 0; i < meshPointers.Length; i++)
                {
                    TR4Mesh mesh = new TR4Mesh();
                    meshes.Add(mesh);

                    uint meshPointer = meshPointers[i];
                    br.BaseStream.Position = meshPointer;

                    //Pointer
                    mesh.Pointer = meshPointer;

                    //Centre
                    mesh.Centre = TR2FileReadUtilities.ReadVertex(br);

                    //CollRadius
                    mesh.CollRadius = br.ReadInt32();

                    //Vertices
                    mesh.NumVertices = br.ReadInt16();
                    mesh.Vertices = new TRVertex[mesh.NumVertices];
                    for (int j = 0; j < mesh.NumVertices; j++)
                    {
                        mesh.Vertices[j] = TR2FileReadUtilities.ReadVertex(br);
                    }

                    //Lights or Normals
                    mesh.NumNormals = br.ReadInt16();
                    if (mesh.NumNormals > 0)
                    {
                        mesh.Normals = new TRVertex[mesh.NumNormals];
                        for (int j = 0; j < mesh.NumNormals; j++)
                        {
                            mesh.Normals[j] = TR2FileReadUtilities.ReadVertex(br);
                        }
                    }
                    else
                    {
                        mesh.Lights = new short[Math.Abs(mesh.NumNormals)];
                        for (int j = 0; j < mesh.Lights.Length; j++)
                        {
                            mesh.Lights[j] = br.ReadInt16();
                        }
                    }

                    //Textured Rectangles
                    mesh.NumTexturedRectangles = br.ReadInt16();
                    mesh.TexturedRectangles = new TR4MeshFace4[mesh.NumTexturedRectangles];
                    for (int j = 0; j < mesh.NumTexturedRectangles; j++)
                    {
                        mesh.TexturedRectangles[j] = TR4FileReadUtilities.ReadTR4MeshFace4(br);
                    }

                    //Textured Triangles
                    mesh.NumTexturedTriangles = br.ReadInt16();
                    mesh.TexturedTriangles = new TR4MeshFace3[mesh.NumTexturedTriangles];
                    for (int j = 0; j < mesh.NumTexturedTriangles; j++)
                    {
                        mesh.TexturedTriangles[j] = TR4FileReadUtilities.ReadTR4MeshFace3(br);
                    }

                    // There may be alignment padding at the end of the mesh, but rather than
                    // storing it, when the mesh is serialized the alignment should be considered.
                    // It seems to be 4-byte alignment for mesh data. The basestream position is
                    // moved to the next pointer in the next iteration, so we don't need to process
                    // the additional data here.
                    // See https://www.tombraiderforums.com/archive/index.php/t-215247.html
                }
            }

            return meshes.ToArray();
        }

19 Source : TR4FileReadUtilities.cs
with MIT License
from DanzaG

public static TR4Animation ReadAnimation(BinaryReader reader)
        {
            return new TR4Animation
            {
                FrameOffset = reader.ReadUInt32(),
                FrameRate = reader.ReadByte(),
                FrameSize = reader.ReadByte(),
                StateID = reader.ReadUInt16(),
                Speed = new FixedFloat32
                {
                    Whole = reader.ReadInt16(),
                    Fraction = reader.ReadUInt16()
                },
                Accel = new FixedFloat32
                {
                    Whole = reader.ReadInt16(),
                    Fraction = reader.ReadUInt16()
                },
                SpeedLateral = new FixedFloat32
                {
                    Whole = reader.ReadInt16(),
                    Fraction = reader.ReadUInt16()
                },
                AccelLateral = new FixedFloat32
                {
                    Whole = reader.ReadInt16(),
                    Fraction = reader.ReadUInt16()
                },
                FrameStart = reader.ReadUInt16(),
                FrameEnd = reader.ReadUInt16(),
                NextAnimation = reader.ReadUInt16(),
                NextFrame = reader.ReadUInt16(),
                NumStateChanges = reader.ReadUInt16(),
                StateChangeOffset = reader.ReadUInt16(),
                NumAnimCommands = reader.ReadUInt16(),
                AnimCommand = reader.ReadUInt16()
            };
        }

19 Source : TR4FileReadUtilities.cs
with MIT License
from DanzaG

public static TR4FlyByCamera ReadFlybyCamera(BinaryReader reader)
        {
            return new TR4FlyByCamera
            {
                X = reader.ReadInt32(),
                Y = reader.ReadInt32(),
                Z = reader.ReadInt32(),
                dx = reader.ReadInt32(),
                dy = reader.ReadInt32(),
                dz = reader.ReadInt32(),
                Sequence = reader.ReadByte(),
                Index = reader.ReadByte(),
                FOV = reader.ReadUInt16(),
                Roll = reader.ReadInt16(),
                Timer = reader.ReadUInt16(),
                Speed = reader.ReadUInt16(),
                Flags = reader.ReadUInt16(),
                RoomID = reader.ReadUInt32()
            };
        }

19 Source : TR4FileReadUtilities.cs
with MIT License
from DanzaG

public static TR4Enreplacedy ReadEnreplacedy(BinaryReader reader)
        {
            return new TR4Enreplacedy()
            {
                TypeID = reader.ReadInt16(),
                Room = reader.ReadInt16(),
                X = reader.ReadInt32(),
                Y = reader.ReadInt32(),
                Z = reader.ReadInt32(),
                Angle = reader.ReadInt16(),
                Intensity = reader.ReadInt16(),
                OCB = reader.ReadInt16(),
                Flags = reader.ReadUInt16()
            };
        }

19 Source : TR4FileReadUtilities.cs
with MIT License
from DanzaG

public static TR4AIObject ReadAIObject(BinaryReader reader)
        {
            return new TR4AIObject()
            {
                TypeID = reader.ReadUInt16(),
                Room = reader.ReadUInt16(),
                X = reader.ReadInt32(),
                Y = reader.ReadInt32(),
                Z = reader.ReadInt32(),
                OCB = reader.ReadInt16(),
                Flags = reader.ReadUInt16(),
                Angle = reader.ReadInt32()
            };
        }

19 Source : TR5FileReadUtilities.cs
with MIT License
from DanzaG

public static void PopulateBoxesOverlapsZones(BinaryReader reader, TR5Level lvl)
        {
            //Boxes
            lvl.LevelDataChunk.NumBoxes = reader.ReadUInt32();
            lvl.LevelDataChunk.Boxes = new TR2Box[lvl.LevelDataChunk.NumBoxes];

            for (int i = 0; i < lvl.LevelDataChunk.NumBoxes; i++)
            {
                lvl.LevelDataChunk.Boxes[i] = TR2FileReadUtilities.ReadBox(reader);
            }

            //Overlaps & Zones
            lvl.LevelDataChunk.NumOverlaps = reader.ReadUInt32();
            lvl.LevelDataChunk.Overlaps = new ushort[lvl.LevelDataChunk.NumOverlaps];
            lvl.LevelDataChunk.Zones = new short[10 * lvl.LevelDataChunk.NumBoxes];

            for (int i = 0; i < lvl.LevelDataChunk.NumOverlaps; i++)
            {
                lvl.LevelDataChunk.Overlaps[i] = reader.ReadUInt16();
            }

            for (int i = 0; i < lvl.LevelDataChunk.Zones.Count(); i++)
            {
                lvl.LevelDataChunk.Zones[i] = reader.ReadInt16();
            }
        }

19 Source : TR5FileReadUtilities.cs
with MIT License
from DanzaG

public static void PopulateDemoSoundSampleIndices(BinaryReader reader, TR5Level lvl)
        {
            //Demo Data
            lvl.LevelDataChunk.NumDemoData = reader.ReadUInt16();
            lvl.LevelDataChunk.DemoData = new byte[lvl.LevelDataChunk.NumDemoData];

            for (int i = 0; i < lvl.LevelDataChunk.NumDemoData; i++)
            {
                lvl.LevelDataChunk.DemoData[i] = reader.ReadByte();
            }

            //Sound Map (370 shorts) & Sound Details
            lvl.LevelDataChunk.SoundMap = new short[450];

            for (int i = 0; i < lvl.LevelDataChunk.SoundMap.Count(); i++)
            {
                lvl.LevelDataChunk.SoundMap[i] = reader.ReadInt16();
            }

            lvl.LevelDataChunk.NumSoundDetails = reader.ReadUInt32();
            lvl.LevelDataChunk.SoundDetails = new TR3SoundDetails[lvl.LevelDataChunk.NumSoundDetails];

            for (int i = 0; i < lvl.LevelDataChunk.NumSoundDetails; i++)
            {
                lvl.LevelDataChunk.SoundDetails[i] = TR3FileReadUtilities.ReadSoundDetails(reader);
            }

            //Samples
            lvl.LevelDataChunk.NumSampleIndices = reader.ReadUInt32();
            lvl.LevelDataChunk.SampleIndices = new uint[lvl.LevelDataChunk.NumSampleIndices];

            for (int i = 0; i < lvl.LevelDataChunk.NumSampleIndices; i++)
            {
                lvl.LevelDataChunk.SampleIndices[i] = reader.ReadUInt32();
            }
        }

19 Source : TRFileReadUtilities.cs
with MIT License
from DanzaG

public static TRBox ReadBox(BinaryReader reader)
        {
            return new TRBox()
            {
                ZMin = reader.ReadUInt32(),
                ZMax = reader.ReadUInt32(),
                XMin = reader.ReadUInt32(),
                XMax = reader.ReadUInt32(),
                TrueFloor = reader.ReadInt16(),
                OverlapIndex = reader.ReadUInt16()
            };
        }

19 Source : TRFileReadUtilities.cs
with MIT License
from DanzaG

public static TREnreplacedy ReadEnreplacedy(BinaryReader reader)
        {
            return new TREnreplacedy()
            {
                TypeID = reader.ReadInt16(),
                Room = reader.ReadInt16(),
                X = reader.ReadInt32(),
                Y = reader.ReadInt32(),
                Z = reader.ReadInt32(),
                Angle = reader.ReadInt16(),
                Intensity = reader.ReadInt16(),
                Flags = reader.ReadUInt16()
            };
        }

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TRSpriteTexture ReadSpriteTexture(BinaryReader reader)
        {
            return new TRSpriteTexture()
            {
                Atlas = reader.ReadUInt16(),
                X = reader.ReadByte(),
                Y = reader.ReadByte(),
                Width = reader.ReadUInt16(),
                Height = reader.ReadUInt16(),
                LeftSide = reader.ReadInt16(),
                TopSide = reader.ReadInt16(),
                RightSide = reader.ReadInt16(),
                BottomSide = reader.ReadInt16()
            };
        }

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TRSpriteSequence ReadSpriteSequence(BinaryReader reader)
        {
            return new TRSpriteSequence()
            {
                SpriteID = reader.ReadInt32(),
                NegativeLength = reader.ReadInt16(),
                Offset = reader.ReadInt16()
            };
        }

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TRCamera ReadCamera(BinaryReader reader)
        {
            return new TRCamera()
            {
                X = reader.ReadInt32(),
                Y = reader.ReadInt32(),
                Z = reader.ReadInt32(),
                Room = reader.ReadInt16(),
                Flag = reader.ReadUInt16()
            };
        }

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TRCinematicFrame ReadCinematicFrame(BinaryReader reader)
        {
            return new TRCinematicFrame()
            {
                TargetX = reader.ReadInt16(),
                TargetY = reader.ReadInt16(),
                TargetZ = reader.ReadInt16(),
                PosZ = reader.ReadInt16(),
                PosY = reader.ReadInt16(),
                PosX = reader.ReadInt16(),
                FOV = reader.ReadInt16(),
                Roll = reader.ReadInt16()
            };
        }

19 Source : TR4FileReadUtilities.cs
with MIT License
from DanzaG

public static void PopulateRooms(BinaryReader reader, TR4Level lvl)
        {
            lvl.LevelDataChunk.Unused = reader.ReadUInt32();
            lvl.LevelDataChunk.NumRooms = reader.ReadUInt16();
            lvl.LevelDataChunk.Rooms = new TR4Room[lvl.LevelDataChunk.NumRooms];

            for (int i = 0; i < lvl.LevelDataChunk.NumRooms; i++)
            {
                TR4Room room = new TR4Room();

                //Grab info
                room.Info = new TRRoomInfo
                {
                    X = reader.ReadInt32(),
                    Z = reader.ReadInt32(),
                    YBottom = reader.ReadInt32(),
                    YTop = reader.ReadInt32()
                };

                //Grab data
                room.NumDataWords = reader.ReadUInt32();
                room.Data = new ushort[room.NumDataWords];
                for (int j = 0; j < room.NumDataWords; j++)
                {
                    room.Data[j] = reader.ReadUInt16();
                }

                //Store what we just read
                room.RoomData = ConvertToRoomData(room);

                //Portals
                room.NumPortals = reader.ReadUInt16();
                room.Portals = new TRRoomPortal[room.NumPortals];
                for (int j = 0; j < room.NumPortals; j++)
                {
                    room.Portals[j] = TR2FileReadUtilities.ReadRoomPortal(reader);
                }

                //Sectors
                room.NumZSectors = reader.ReadUInt16();
                room.NumXSectors = reader.ReadUInt16();
                room.Sectors = new TRRoomSector[room.NumXSectors * room.NumZSectors];
                for (int j = 0; j < (room.NumXSectors * room.NumZSectors); j++)
                {
                    room.Sectors[j] = TR2FileReadUtilities.ReadRoomSector(reader);
                }

                //Lighting
                room.AmbientIntensity = reader.ReadInt16();
                room.LightMode = reader.ReadInt16();
                room.NumLights = reader.ReadUInt16();
                room.Lights = new TR4RoomLight[room.NumLights];
                for (int j = 0; j < room.NumLights; j++)
                {
                    room.Lights[j] = TR4FileReadUtilities.ReadRoomLight(reader);
                }

                //Static meshes
                room.NumStaticMeshes = reader.ReadUInt16();
                room.StaticMeshes = new TR3RoomStaticMesh[room.NumStaticMeshes];
                for (int j = 0; j < room.NumStaticMeshes; j++)
                {
                    room.StaticMeshes[j] = TR3FileReadUtilities.ReadRoomStaticMesh(reader);
                }

                room.AlternateRoom = reader.ReadInt16();
                room.Flags = reader.ReadInt16();
                room.WaterScheme = reader.ReadByte();
                room.ReverbInfo = reader.ReadByte();
                room.Filler = reader.ReadByte();

                lvl.LevelDataChunk.Rooms[i] = room;
            }
        }

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TRAnimCommand ReadAnimCommand(BinaryReader reader)
        {
            return new TRAnimCommand()
            {
                Value = reader.ReadInt16()
            };
        }

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TR2Box ReadBox(BinaryReader reader)
        {
            return new TR2Box()
            {
                ZMin = reader.ReadByte(),
                ZMax = reader.ReadByte(),
                XMin = reader.ReadByte(),
                XMax = reader.ReadByte(),
                TrueFloor = reader.ReadInt16(),
                OverlapIndex = reader.ReadInt16()
            };
        }

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TR2Enreplacedy ReadEnreplacedy(BinaryReader reader)
        {
            return new TR2Enreplacedy()
            {
                TypeID = reader.ReadInt16(),
                Room = reader.ReadInt16(),
                X = reader.ReadInt32(),
                Y = reader.ReadInt32(),
                Z = reader.ReadInt32(),
                Angle = reader.ReadInt16(),
                Intensity1 = reader.ReadInt16(),
                Intensity2 = reader.ReadInt16(),
                Flags = reader.ReadUInt16()
            };
        }

19 Source : TR4FileReadUtilities.cs
with MIT License
from DanzaG

public static void PopulateBoxesOverlapsZones(BinaryReader reader, TR4Level lvl)
        {
            //Boxes
            lvl.LevelDataChunk.NumBoxes = reader.ReadUInt32();
            lvl.LevelDataChunk.Boxes = new TR2Box[lvl.LevelDataChunk.NumBoxes];

            for (int i = 0; i < lvl.LevelDataChunk.NumBoxes; i++)
            {
                lvl.LevelDataChunk.Boxes[i] = TR2FileReadUtilities.ReadBox(reader);
            }

            //Overlaps & Zones
            lvl.LevelDataChunk.NumOverlaps = reader.ReadUInt32();
            lvl.LevelDataChunk.Overlaps = new ushort[lvl.LevelDataChunk.NumOverlaps];
            lvl.LevelDataChunk.Zones = new short[10 * lvl.LevelDataChunk.NumBoxes];

            for (int i = 0; i < lvl.LevelDataChunk.NumOverlaps; i++)
            {
                lvl.LevelDataChunk.Overlaps[i] = reader.ReadUInt16();
            }

            for (int i = 0; i < lvl.LevelDataChunk.Zones.Count(); i++)
            {
                lvl.LevelDataChunk.Zones[i] = reader.ReadInt16();
            }
        }

19 Source : TRLevelReader.cs
with MIT License
from DanzaG

public TRLevel ReadLevel(string Filename)
        {
            if (!Filename.ToUpper().Contains("PHD"))
            {
                throw new NotImplementedException("File reader only supports TR1 levels");
            }

            TRLevel level = new TRLevel();
            reader = new BinaryReader(File.Open(Filename, FileMode.Open));

            //Version
            level.Version = reader.ReadUInt32();
            if (level.Version != Versions.TR1)
            {
                throw new NotImplementedException("File reader only suppors TR1 levels");
            }

            level.NumImages = reader.ReadUInt32();
            level.Images8 = new TRTexImage8[level.NumImages];

            //Initialize the texture arrays
            for (int i = 0; i < level.NumImages; i++)
            {
                level.Images8[i] = new TRTexImage8();
            }

            //For each texture8 there are 256 * 256 bytes (65536) we can just do a straight byte read
            for (int i = 0; i < level.NumImages; i++)
            {
                level.Images8[i].Pixels = reader.ReadBytes(256 * 256);
            }

            //Rooms
            level.Unused = reader.ReadUInt32();
            level.NumRooms = reader.ReadUInt16();
            level.Rooms = new TRRoom[level.NumRooms];

            for (int i = 0; i < level.NumRooms; i++)
            {
                TRRoom room = new TRRoom();

                //Grab info
                room.Info = new TRRoomInfo
                {
                    X = reader.ReadInt32(),
                    Z = reader.ReadInt32(),
                    YBottom = reader.ReadInt32(),
                    YTop = reader.ReadInt32()
                };

                //Grab data
                room.NumDataWords = reader.ReadUInt32();
                room.Data = new ushort[room.NumDataWords];
                for (int j = 0; j < room.NumDataWords; j++)
                {
                    room.Data[j] = reader.ReadUInt16();
                }

                //Store what we just read
                room.RoomData = ConvertToRoomData(room);

                //Portals
                room.NumPortals = reader.ReadUInt16();
                room.Portals = new TRRoomPortal[room.NumPortals];
                for (int j = 0; j < room.NumPortals; j++)
                {
                    room.Portals[j] = TR2FileReadUtilities.ReadRoomPortal(reader);
                }

                //Sectors
                room.NumZSectors = reader.ReadUInt16();
                room.NumXSectors = reader.ReadUInt16();
                room.Sectors = new TRRoomSector[room.NumXSectors * room.NumZSectors];
                for (int j = 0; j < (room.NumXSectors * room.NumZSectors); j++)
                {
                    room.Sectors[j] = TR2FileReadUtilities.ReadRoomSector(reader);
                }

                //Lighting
                room.AmbientIntensity = reader.ReadInt16();
                room.NumLights = reader.ReadUInt16();
                room.Lights = new TRRoomLight[room.NumLights];
                for (int j = 0; j < room.NumLights; j++)
                {
                    room.Lights[j] = TRFileReadUtilities.ReadRoomLight(reader);
                }

                //Static meshes
                room.NumStaticMeshes = reader.ReadUInt16();
                room.StaticMeshes = new TRRoomStaticMesh[room.NumStaticMeshes];
                for (int j = 0; j < room.NumStaticMeshes; j++)
                {
                    room.StaticMeshes[j] = TRFileReadUtilities.ReadRoomStaticMesh(reader);
                }

                room.AlternateRoom = reader.ReadInt16();
                room.Flags = reader.ReadInt16();

                level.Rooms[i] = room;
            }

            //Floordata
            level.NumFloorData = reader.ReadUInt32();
            level.FloorData = new ushort[level.NumFloorData];

            for (int i = 0; i < level.NumFloorData; i++)
            {
                level.FloorData[i] = reader.ReadUInt16();
            }

            //Mesh Data
            //This tells us how much mesh data (# of words/uint16s) coming up
            //just like the rooms previously.
            level.NumMeshData = reader.ReadUInt32();
            level.RawMeshData = new ushort[level.NumMeshData];

            for (int i = 0; i < level.NumMeshData; i++)
            {
                level.RawMeshData[i] = reader.ReadUInt16();
            }

            //Mesh Pointers
            level.NumMeshPointers = reader.ReadUInt32();
            level.MeshPointers = new uint[level.NumMeshPointers];

            for (int i = 0; i < level.NumMeshPointers; i++)
            {
                level.MeshPointers[i] = reader.ReadUInt32();
            }

            //Mesh Construction
            //level.Meshes = ConstructMeshData(level.NumMeshData, level.NumMeshPointers, level.RawMeshData);
            level.Meshes = ConstructMeshData(level.MeshPointers, level.RawMeshData);

            //Animations
            level.NumAnimations = reader.ReadUInt32();
            level.Animations = new TRAnimation[level.NumAnimations];
            for (int i = 0; i < level.NumAnimations; i++)
            {
                level.Animations[i] = TR2FileReadUtilities.ReadAnimation(reader);
            }

            //State Changes
            level.NumStateChanges = reader.ReadUInt32();
            level.StateChanges = new TRStateChange[level.NumStateChanges];
            for (int i = 0; i < level.NumStateChanges; i++)
            {
                level.StateChanges[i] = TR2FileReadUtilities.ReadStateChange(reader);
            }

            //Animation Dispatches
            level.NumAnimDispatches = reader.ReadUInt32();
            level.AnimDispatches = new TRAnimDispatch[level.NumAnimDispatches];
            for (int i = 0; i < level.NumAnimDispatches; i++)
            {
                level.AnimDispatches[i] = TR2FileReadUtilities.ReadAnimDispatch(reader);
            }

            //Animation Commands
            level.NumAnimCommands = reader.ReadUInt32();
            level.AnimCommands = new TRAnimCommand[level.NumAnimCommands];
            for (int i = 0; i < level.NumAnimCommands; i++)
            {
                level.AnimCommands[i] = TR2FileReadUtilities.ReadAnimCommand(reader);
            }

            //Mesh Trees
            level.NumMeshTrees = reader.ReadUInt32();
            level.NumMeshTrees /= 4;
            level.MeshTrees = new TRMeshTreeNode[level.NumMeshTrees];
            for (int i = 0; i < level.NumMeshTrees; i++)
            {
                level.MeshTrees[i] = TR2FileReadUtilities.ReadMeshTreeNode(reader);
            }

            //Frames
            level.NumFrames = reader.ReadUInt32();
            level.Frames = new ushort[level.NumFrames];
            for (int i = 0; i < level.NumFrames; i++)
            {
                level.Frames[i] = reader.ReadUInt16();
            }

            //Models
            level.NumModels = reader.ReadUInt32();
            level.Models = new TRModel[level.NumModels];

            for (int i = 0; i < level.NumModels; i++)
            {
                level.Models[i] = TR2FileReadUtilities.ReadModel(reader);
            }

            //Static Meshes
            level.NumStaticMeshes = reader.ReadUInt32();
            level.StaticMeshes = new TRStaticMesh[level.NumStaticMeshes];

            for (int i = 0; i < level.NumStaticMeshes; i++)
            {
                level.StaticMeshes[i] = TR2FileReadUtilities.ReadStaticMesh(reader);
            }

            //Object Textures
            level.NumObjectTextures = reader.ReadUInt32();
            level.ObjectTextures = new TRObjectTexture[level.NumObjectTextures];

            for (int i = 0; i < level.NumObjectTextures; i++)
            {
                level.ObjectTextures[i] = TR2FileReadUtilities.ReadObjectTexture(reader);
            }

            //Sprite Textures
            level.NumSpriteTextures = reader.ReadUInt32();
            level.SpriteTextures = new TRSpriteTexture[level.NumSpriteTextures];

            for (int i = 0; i < level.NumSpriteTextures; i++)
            {
                level.SpriteTextures[i] = TR2FileReadUtilities.ReadSpriteTexture(reader);
            }

            //Sprite Sequences
            level.NumSpriteSequences = reader.ReadUInt32();
            level.SpriteSequences = new TRSpriteSequence[level.NumSpriteSequences];

            for (int i = 0; i < level.NumSpriteSequences; i++)
            {
                level.SpriteSequences[i] = TR2FileReadUtilities.ReadSpriteSequence(reader);
            }

            //Cameras
            level.NumCameras = reader.ReadUInt32();
            level.Cameras = new TRCamera[level.NumCameras];

            for (int i = 0; i < level.NumCameras; i++)
            {
                level.Cameras[i] = TR2FileReadUtilities.ReadCamera(reader);
            }

            //Sound Sources
            level.NumSoundSources = reader.ReadUInt32();
            level.SoundSources = new TRSoundSource[level.NumSoundSources];

            for (int i = 0; i < level.NumSoundSources; i++)
            {
                level.SoundSources[i] = TR2FileReadUtilities.ReadSoundSource(reader);
            }

            //Boxes
            level.NumBoxes = reader.ReadUInt32();
            level.Boxes = new TRBox[level.NumBoxes];

            for (int i = 0; i < level.NumBoxes; i++)
            {
                level.Boxes[i] = TRFileReadUtilities.ReadBox(reader);
            }

            //Overlaps & Zones
            level.NumOverlaps = reader.ReadUInt32();
            level.Overlaps = new ushort[level.NumOverlaps];

            for (int i = 0; i < level.NumOverlaps; i++)
            {
                level.Overlaps[i] = reader.ReadUInt16();
            }

            level.Zones = new ushort[6 * level.NumBoxes];

            for (int i = 0; i < level.Zones.Count(); i++)
            {
                level.Zones[i] = reader.ReadUInt16();
            }

            //Animated Textures - the data stores the total number of ushorts to read (NumAnimatedTextures)
            //followed by a ushort to describe the number of actual texture group objects.
            level.NumAnimatedTextures = reader.ReadUInt32();
            level.AnimatedTextures = new TRAnimatedTexture[reader.ReadUInt16()];
            for (int i = 0; i < level.AnimatedTextures.Length; i++)
            {
                level.AnimatedTextures[i] = TR2FileReadUtilities.ReadAnimatedTexture(reader);
            }

            //Enreplacedies
            level.NumEnreplacedies = reader.ReadUInt32();
            level.Enreplacedies = new TREnreplacedy[level.NumEnreplacedies];

            for (int i = 0; i < level.NumEnreplacedies; i++)
            {
                level.Enreplacedies[i] = TRFileReadUtilities.ReadEnreplacedy(reader);
            }

            //Light Map - 32 * 256 = 8192 bytes
            level.LightMap = new byte[32 * 256];

            for (int i = 0; i < level.LightMap.Count(); i++)
            {
                level.LightMap[i] = reader.ReadByte();
            }

            level.Palette = PopulateColourPalette(reader.ReadBytes((int)MAX_PALETTE_SIZE * 3));

            //Cinematic Frames
            level.NumCinematicFrames = reader.ReadUInt16();
            level.CinematicFrames = new TRCinematicFrame[level.NumCinematicFrames];

            for (int i = 0; i < level.NumCinematicFrames; i++)
            {
                level.CinematicFrames[i] = TR2FileReadUtilities.ReadCinematicFrame(reader);
            }

            //Demo Data
            level.NumDemoData = reader.ReadUInt16();
            level.DemoData = new byte[level.NumDemoData];

            for (int i = 0; i < level.NumDemoData; i++)
            {
                level.DemoData[i] = reader.ReadByte();
            }

            //Sound Map & Sound Details
            level.SoundMap = new short[256];

            for (int i = 0; i < level.SoundMap.Count(); i++)
            {
                level.SoundMap[i] = reader.ReadInt16();
            }

            level.NumSoundDetails = reader.ReadUInt32();
            level.SoundDetails = new TRSoundDetails[level.NumSoundDetails];

            for (int i = 0; i < level.NumSoundDetails; i++)
            {
                level.SoundDetails[i] = TR2FileReadUtilities.ReadSoundDetails(reader);
            }

            //Samples
            level.NumSamples = reader.ReadUInt32();
            level.Samples = new byte[level.NumSamples];

            for (int i = 0; i < level.NumSamples; i++)
            {
                level.Samples[i] = reader.ReadByte();
            }

            level.NumSampleIndices = reader.ReadUInt32();
            level.SampleIndices = new uint[level.NumSampleIndices];

            for (int i = 0; i < level.NumSampleIndices; i++)
            {
                level.SampleIndices[i] = reader.ReadUInt32();
            }

            Debug.replacedert(reader.BaseStream.Position == reader.BaseStream.Length);

            reader.Close();

            return level;
        }

19 Source : PreferencesBackend.cs
with GNU General Public License v3.0
from deathkiller

void IDualityBackend.Init()
        {
            data = new Dictionary<string, object>();

            string path = GetSettingsPath();
            if (!FileOp.Exists(path)) {
                dirty = true;
                return;
            }

            try {
                using (Stream s = FileOp.Open(path, FileAccessMode.Read))
                using (BinaryReader r = new BinaryReader(s)) {
                    ushort n = r.ReadUInt16();

                    for (ushort i = 0; i < n; i++) {
                        string key = r.ReadString();
                        byte type = r.ReadByte();

                        switch (type) {
                            case 0: data[key] = r.ReadString(); break; // String
                            case 1: data[key] = r.ReadBoolean(); break; // Bool
                            case 2: data[key] = r.ReadByte(); break; // Byte
                            case 3: data[key] = r.ReadInt32(); break; // Int
                            case 4: data[key] = r.ReadInt64(); break; // Long
                            case 5: data[key] = r.ReadInt16(); break; // Short
                            case 6: data[key] = r.ReadUInt32(); break; // Uint

                            case 10: { // String Array
                                byte count = r.ReadByte();
                                string[] values = new string[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadString();
                                }
                                data[key] = values;
                                break;
                            }
                            case 11: { // Bool Array
                                byte count = r.ReadByte();
                                bool[] values = new bool[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadBoolean();
                                }
                                data[key] = values;
                                break;
                            }
                            case 12: { // Byte Array
                                byte count = r.ReadByte();
                                byte[] values = new byte[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadByte();
                                }
                                data[key] = values;
                                break;
                            }
                            case 13: { // Int Array
                                byte count = r.ReadByte();
                                int[] values = new int[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadInt32();
                                }
                                data[key] = values;
                                break;
                            }
                            case 14: { // Long Array
                                byte count = r.ReadByte();
                                long[] values = new long[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadInt64();
                                }
                                data[key] = values;
                                break;
                            }
                            case 15: { // Short Array
                                byte count = r.ReadByte();
                                short[] values = new short[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadInt16();
                                }
                                data[key] = values;
                                break;
                            }
                            case 16: { // Uint Array
                                byte count = r.ReadByte();
                                uint[] values = new uint[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadUInt32();
                                }
                                data[key] = values;
                                break;
                            }
                        }
                    }
                }
            } catch (Exception ex) {
                Log.Write(LogType.Error, "Can't load preferences: " + ex);
            }
        }

19 Source : PreferencesBackend.cs
with GNU General Public License v3.0
from deathkiller

void IDualityBackend.Init()
        {
            data = new Dictionary<string, object>();

            sharedPrefs = Application.Context.GetSharedPreferences(App.replacedemblyreplacedle, FileCreationMode.Private);

            string base64 = sharedPrefs.GetString("Root", null);
            if (string.IsNullOrEmpty(base64)) {
                // No preferences found
                dirty = true;
                return;
            }

            byte[] buffer = Base64.Decode(base64, Base64Flags.NoPadding | Base64Flags.NoWrap);

            using (BinaryReader r = new BinaryReader(new MemoryStream(buffer, false))) {
                ushort n = r.ReadUInt16();

                for (ushort i = 0; i < n; i++) {
                    string key = r.ReadString();
                    byte type = r.ReadByte();

                    switch (type) {
                        case 0: data[key] = r.ReadString(); break; // String
                        case 1: data[key] = r.ReadBoolean(); break; // Bool
                        case 2: data[key] = r.ReadByte(); break; // Byte
                        case 3: data[key] = r.ReadInt32(); break; // Int
                        case 4: data[key] = r.ReadInt64(); break; // Long
                        case 5: data[key] = r.ReadInt16(); break; // Short
                        case 6: data[key] = r.ReadUInt32(); break; // Uint

                        case 10: { // String Array
                            byte count = r.ReadByte();
                            string[] values = new string[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadString();
                            }
                            data[key] = values;
                            break;
                        }
                        case 11: { // Bool Array
                            byte count = r.ReadByte();
                            bool[] values = new bool[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadBoolean();
                            }
                            data[key] = values;
                            break;
                        }
                        case 12: { // Byte Array
                            byte count = r.ReadByte();
                            byte[] values = new byte[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadByte();
                            }
                            data[key] = values;
                            break;
                        }
                        case 13: { // Int Array
                            byte count = r.ReadByte();
                            int[] values = new int[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadInt32();
                            }
                            data[key] = values;
                            break;
                        }
                        case 14: { // Long Array
                            byte count = r.ReadByte();
                            long[] values = new long[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadInt64();
                            }
                            data[key] = values;
                            break;
                        }
                        case 15: { // Short Array
                            byte count = r.ReadByte();
                            short[] values = new short[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadInt16();
                            }
                            data[key] = values;
                            break;
                        }
                        case 16: { // Uint Array
                            byte count = r.ReadByte();
                            uint[] values = new uint[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadUInt32();
                            }
                            data[key] = values;
                            break;
                        }
                    }
                }
            }
        }

19 Source : JJ2Block.cs
with GNU General Public License v3.0
from deathkiller

public short ReadInt16()
        {
            return reader.ReadInt16();
        }

19 Source : TileData.cs
with GNU General Public License v3.0
from deccer

internal static void Initialize(string mapDirectory)
        {
            ItemTable = new ItemData[0x10000];
            LandTable = new LandData[0x4000];

            var filePath = Path.Combine(mapDirectory, "tiledata.mul");

            using var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
            var bin = new BinaryReader(fs);

            var is7090 = fs.Length == 3188736;
            var is7000 = fs.Length == 1644544;

            for (var i = 0; i < 0x4000; i++)
            {
                // header
                if (is7090)
                {
                    if (i == 1 || i > 0 && (i & 0x1F) == 0)
                    {
                        bin.ReadInt32();
                    }
                }
                else if ((i & 0x1F) == 0)
                {
                    bin.ReadInt32();
                }

                var flags = (TileFlag)(is7090 ? bin.ReadInt64() : bin.ReadInt32());
                bin.ReadInt16(); // skip 2 bytes -- textureID

                LandTable[i] = new LandData(ReadNameString(bin), flags);
            }

            var length = is7090 ? 0x10000 :
                is7000 ? 0x8000 : 0x4000;

            for (var i = 0; i < length; i++)
            {
                if ((i & 0x1F) == 0)
                {
                    bin.ReadInt32(); // header
                }

                var flags = (TileFlag)(is7090 ? bin.ReadInt64() : bin.ReadInt32());
                int weight = bin.ReadByte();
                int quality = bin.ReadByte();
                bin.ReadInt16();
                bin.ReadByte();
                int quanreplacedy = bin.ReadByte();
                bin.ReadInt32();
                bin.ReadByte();
                int value = bin.ReadByte();
                int height = bin.ReadByte();

                ItemTable[i] = new ItemData(
                    ReadNameString(bin),
                    flags,
                    weight,
                    quality,
                    quanreplacedy,
                    value,
                    height
                );
            }

            MaxLandValue = LandTable.Length - 1;
            MaxItemValue = ItemTable.Length - 1;
        }

19 Source : TextureLoader.cs
with Apache License 2.0
from decentraland

public static Texture2D LoadTGA(Stream TGAStream)
    {

        using (BinaryReader r = new BinaryReader(TGAStream))
        {
            // Skip some header info we don't care about.
            // Even if we did care, we have to move the stream seek point to the beginning,
            // as the previous method in the workflow left it at the end.
            r.BaseStream.Seek(12, SeekOrigin.Begin);

            short width = r.ReadInt16();
            short height = r.ReadInt16();
            int bitDepth = r.ReadByte();

            // Skip a byte of header information we don't care about.
            r.BaseStream.Seek(1, SeekOrigin.Current);

            Texture2D tex = new Texture2D(width, height);
            Color32[] pulledColors = new Color32[width * height];

            if (bitDepth == 32)
            {
                for (int i = 0; i < width * height; i++)
                {
                    byte red = r.ReadByte();
                    byte green = r.ReadByte();
                    byte blue = r.ReadByte();
                    byte alpha = r.ReadByte();

                    pulledColors[i] = new Color32(blue, green, red, alpha);
                }
            }
            else if (bitDepth == 24)
            {
                for (int i = 0; i < width * height; i++)
                {
                    byte red = r.ReadByte();
                    byte green = r.ReadByte();
                    byte blue = r.ReadByte();

                    pulledColors[i] = new Color32(blue, green, red, 1);
                }
            }
            else
            {
                throw new Exception("TGA texture had non 32/24 bit depth.");
            }

            tex.SetPixels32(pulledColors);
            tex.Apply();
            return tex;

        }
    }

19 Source : ResourcesFile.cs
with MIT License
from deepakkumar1984

private object LoadObjectV1(int dataOffset)
		{
			Debug.replacedert(System.Threading.Monitor.IsEntered(reader));
			reader.Seek(dataSectionPosition + dataOffset, SeekOrigin.Begin);
			int typeIndex = reader.Read7BitEncodedInt();
			if (typeIndex == -1)
				return null;
			string typeName = FindType(typeIndex);
			int comma = typeName.IndexOf(',');
			if (comma > 0) {
				// strip replacedembly name
				typeName = typeName.Substring(0, comma);
			}
			switch (typeName) {
				case "System.String":
					return reader.ReadString();
				case "System.Byte":
					return reader.ReadByte();
				case "System.SByte":
					return reader.ReadSByte();
				case "System.Int16":
					return reader.ReadInt16();
				case "System.UInt16":
					return reader.ReadUInt16();
				case "System.Int32":
					return reader.ReadInt32();
				case "System.UInt32":
					return reader.ReadUInt32();
				case "System.Int64":
					return reader.ReadInt64();
				case "System.UInt64":
					return reader.ReadUInt64();
				case "System.Single":
					return reader.ReadSingle();
				case "System.Double":
					return reader.ReadDouble();
				case "System.DateTime":
					// Ideally we should use DateTime's ToBinary & FromBinary,
					// but we can't for compatibility reasons.
					return new DateTime(reader.ReadInt64());
				case "System.TimeSpan":
					return new TimeSpan(reader.ReadInt64());
				case "System.Decimal":
					int[] bits = new int[4];
					for (int i = 0; i < bits.Length; i++)
						bits[i] = reader.ReadInt32();
					return new decimal(bits);
				default:
					return new ResourceSerializedObject(FindType(typeIndex), this, reader.BaseStream.Position);
			}
		}

19 Source : ResourcesFile.cs
with MIT License
from deepakkumar1984

private object LoadObjectV2(int dataOffset)
		{
			Debug.replacedert(System.Threading.Monitor.IsEntered(reader));
			reader.Seek(dataSectionPosition + dataOffset, SeekOrigin.Begin);
			var typeCode = (ResourceTypeCode)reader.Read7BitEncodedInt();
			switch (typeCode) {
				case ResourceTypeCode.Null:
					return null;

				case ResourceTypeCode.String:
					return reader.ReadString();

				case ResourceTypeCode.Boolean:
					return reader.ReadBoolean();

				case ResourceTypeCode.Char:
					return (char)reader.ReadUInt16();

				case ResourceTypeCode.Byte:
					return reader.ReadByte();

				case ResourceTypeCode.SByte:
					return reader.ReadSByte();

				case ResourceTypeCode.Int16:
					return reader.ReadInt16();

				case ResourceTypeCode.UInt16:
					return reader.ReadUInt16();

				case ResourceTypeCode.Int32:
					return reader.ReadInt32();

				case ResourceTypeCode.UInt32:
					return reader.ReadUInt32();

				case ResourceTypeCode.Int64:
					return reader.ReadInt64();

				case ResourceTypeCode.UInt64:
					return reader.ReadUInt64();

				case ResourceTypeCode.Single:
					return reader.ReadSingle();

				case ResourceTypeCode.Double:
					return reader.ReadDouble();

				case ResourceTypeCode.Decimal:
					return reader.ReadDecimal();

				case ResourceTypeCode.DateTime:
					// Use DateTime's ToBinary & FromBinary.
					long data = reader.ReadInt64();
					return DateTime.FromBinary(data);

				case ResourceTypeCode.TimeSpan:
					long ticks = reader.ReadInt64();
					return new TimeSpan(ticks);

				// Special types
				case ResourceTypeCode.ByteArray: {
						int len = reader.ReadInt32();
						if (len < 0) {
							throw new BadImageFormatException("Resource with negative length");
						}
						return reader.ReadBytes(len);
					}

				case ResourceTypeCode.Stream: {
						int len = reader.ReadInt32();
						if (len < 0) {
							throw new BadImageFormatException("Resource with negative length");
						}
						byte[] bytes = reader.ReadBytes(len);
						return new MemoryStream(bytes, writable: false);
					}

				default:
					if (typeCode < ResourceTypeCode.StartOfUserTypes) {
						throw new BadImageFormatException("Invalid typeCode");
					}
					return new ResourceSerializedObject(FindType(typeCode - ResourceTypeCode.StartOfUserTypes), this, reader.BaseStream.Position);
			}
		}

19 Source : DBFHeader.cs
with GNU General Public License v3.0
from DeepHydro

internal void Read(BinaryReader dataInput)
        {
            _signature = dataInput.ReadByte(); /* 0 */
            _year = dataInput.ReadByte(); /* 1 */
            _month = dataInput.ReadByte(); /* 2 */
            _day = dataInput.ReadByte(); /* 3 */
            _numberOfRecords = dataInput.ReadInt32(); /* 4-7 */

            _headerLength = dataInput.ReadInt16(); /* 8-9 */
            _recordLength = dataInput.ReadInt16(); /* 10-11 */

            _reserv1 = dataInput.ReadInt16(); /* 12-13 */
            _incompleteTransaction = dataInput.ReadByte(); /* 14 */
            _encryptionFlag = dataInput.ReadByte(); /* 15 */
            _freeRecordThread = dataInput.ReadInt32(); /* 16-19 */
            _reserv2 = dataInput.ReadInt32(); /* 20-23 */
            _reserv3 = dataInput.ReadInt32(); /* 24-27 */
            _mdxFlag = dataInput.ReadByte(); /* 28 */
            _languageDriver = dataInput.ReadByte(); /* 29 */
            reserv4 = dataInput.ReadInt16(); /* 30-31 */


            List<DBFField> v_fields = new List<DBFField>();

            DBFField field = DBFField.CreateField(dataInput); /* 32 each */
            while (field != null)
            {
                v_fields.Add(field);
                field = DBFField.CreateField(dataInput);
            }

            _fieldArray = v_fields.ToArray();
            //System.out.println( "Number of fields: " + _fieldArray.length);
        }

19 Source : DBFField.cs
with GNU General Public License v3.0
from DeepHydro

public bool Read(BinaryReader aReader)
        {
            byte t_byte = aReader.ReadByte(); /* 0 */
            if (t_byte == DBFFieldType.EndOfField)
            {
                //System.out.println( "End of header found");
                return false;
            }

            aReader.Read(fieldName, 1, 10); /* 1-10 */
            fieldName[0] = t_byte;

            for (int i = 0; i < fieldName.Length; i++)
            {
                if (fieldName[i]
                    == 0)
                {
                    nameNullIndex = i;
                    break;
                }
            }

            dataType = aReader.ReadByte(); /* 11 */
            reserv1 = aReader.ReadInt32(); /* 12-15 */
            fieldLength = aReader.ReadByte(); /* 16 */
            decimalCount = aReader.ReadByte(); /* 17 */
            reserv2 = aReader.ReadInt16(); /* 18-19 */
            workAreaId = aReader.ReadByte(); /* 20 */
            reserv3 = aReader.ReadInt16(); /* 21-22 */
            setFieldsFlag = aReader.ReadByte(); /* 23 */
            aReader.Read(reserv4, 0, 7); /* 24-30 */
            indexFieldFlag = aReader.ReadByte(); /* 31 */
            return true;
        }

19 Source : BufferStream.cs
with MIT License
from dereksorensen

public short GetShort()
        {
            return _reader.ReadInt16();
        }

19 Source : Audio.cs
with MIT License
from dereksorensen

public static byte[] LoadWave(Stream stream, out int channels, out int bits, out int rate)
        {
            if (stream == null)
                throw new ArgumentNullException("stream");

            using (BinaryReader reader = new BinaryReader(stream))
            {
                // RIFF header
                string signature = new string(reader.ReadChars(4));
                if (signature != "RIFF")
                    throw new NotSupportedException("Specified stream is not a wave file.");

                int riff_chunck_size = reader.ReadInt32();

                string format = new string(reader.ReadChars(4));
                if (format != "WAVE")
                    throw new NotSupportedException("Specified stream is not a wave file.");

                // WAVE header
                string format_signature = new string(reader.ReadChars(4));
                if (format_signature != "fmt ")
                    throw new NotSupportedException("Specified wave file is not supported.");

                int format_chunk_size = reader.ReadInt32();
                int audio_format = reader.ReadInt16();
                int num_channels = reader.ReadInt16();
                int sample_rate = reader.ReadInt32();
                int byte_rate = reader.ReadInt32();
                int block_align = reader.ReadInt16();
                int bits_per_sample = reader.ReadInt16();

                string data_signature = new string(reader.ReadChars(4));
                Console.WriteLine(data_signature);
                if (data_signature != "data")
                    throw new NotSupportedException("Specified wave file is not supported.");

                int data_chunk_size = reader.ReadInt32();

                channels = num_channels;
                bits = bits_per_sample;
                rate = sample_rate;

                return reader.ReadBytes((int)reader.BaseStream.Length);
            }
        }

19 Source : BufferStream.cs
with MIT License
from dereksorensen

public short GetInt16()
        {
            return _reader.ReadInt16();
        }

19 Source : Sound.cs
with MIT License
from DevChrome

private bool LoadFromWav(BinaryReader reader, bool isFromMp3 = false)
		{
			const string Riff = "RIFF";
			const string Wave = "WAVE";
			const string Fmt = "fmt ";

			char[] dump;

			dump = reader.ReadChars(4); // RIFF"
			if (string.Compare(string.Concat(dump), Riff) != 0)
				return false;

			dump = reader.ReadChars(4); // Ignore

			dump = reader.ReadChars(4); // "WAVE"
			if (string.Compare(string.Concat(dump), Wave) != 0)
				return false;

			dump = reader.ReadChars(4); // "fmt "
			if (string.Compare(string.Concat(dump), Fmt) != 0)
				return false;

			dump = reader.ReadChars(4); // Ignore

			WavHeader = new WaveFormatEx()
			{
				FormatTag = reader.ReadInt16(),
				Channels = reader.ReadInt16(),
				SamplesPerSec = reader.ReadInt32(),
				AvgBytesPerSec = reader.ReadInt32(),
				BlockAlign = reader.ReadInt16(),
				BitsPerSample = reader.ReadInt16()
			};
			WavHeader.Size = (short)Marshal.SizeOf(WavHeader);

			if (WavHeader.SamplesPerSec != 44100)
				return false;

			const string Data = "data";

			// Offset 2 characters to reach data.
			// There are 2 extra chars while converting from mp3 for some reason ???
			if (isFromMp3)           
				reader.ReadChars(2); 

			dump = reader.ReadChars(4); // Chunk header
			long chunkSize = reader.ReadUInt32();
			while (string.Compare(string.Concat(dump), Data) != 0)
			{
				reader.BaseStream.Seek(chunkSize, SeekOrigin.Current);
				dump = reader.ReadChars(4);
				chunkSize = reader.ReadUInt32();
			}

			SampleCount = chunkSize / (WavHeader.Channels * (WavHeader.BitsPerSample >> 3));
			Channels = WavHeader.Channels;

			Samples = new short[SampleCount * Channels];

			const float Mult8Bit = (float)short.MaxValue / byte.MaxValue;
			const float Mult24Bit = (float)short.MaxValue / (1 << 24);
			const float Mult32Bit = (float)short.MaxValue / int.MaxValue;

			for (long l = 0; l < Samples.Length; l++)
			{
				// Divide by 8 to convert to bits to bytes 
				switch (WavHeader.BitsPerSample / 8)
				{
					case 1: // 8-bits
						byte b = reader.ReadByte();
						Samples[l] = (short)(b * Mult8Bit);
						break;

					case 2: // 16-bits
						short s = reader.ReadInt16();
						Samples[l] = s;
						break;

					case 3: // 24-bits
						byte[] bs = reader.ReadBytes(3);
						int n = bs[0] | (bs[1] << 8) | (bs[2] << 16);
						Samples[l] = (short)(n * Mult24Bit);
						break;

					case 4: // 32-bits
						int i = reader.ReadInt32();
						Samples[l] = (byte)(i * Mult32Bit);
						break;
				}
			}

			return true;
		}

19 Source : Sprite.cs
with MIT License
from DevChrome

private static Sprite LoadFromSpr(string path)
		{
			Pixel Parse(short col)
			{
				switch (col & 0xF)
				{
					case 0x0: return Pixel.Presets.Black;	
					case 0x1: return Pixel.Presets.DarkBlue;
					case 0x2: return Pixel.Presets.DarkGreen;	
					case 0x3: return Pixel.Presets.DarkCyan;
					case 0x4: return Pixel.Presets.DarkRed; 
					case 0x5: return Pixel.Presets.DarkMagenta;	
					case 0x6: return Pixel.Presets.DarkYellow;	
					case 0x7: return Pixel.Presets.Grey; 
					case 0x8: return Pixel.Presets.DarkGrey;
					case 0x9: return Pixel.Presets.Blue; 
					case 0xA: return Pixel.Presets.Green;
					case 0xB: return Pixel.Presets.Cyan; 
					case 0xC: return Pixel.Presets.Red; 
					case 0xD: return Pixel.Presets.Magenta; 
					case 0xE: return Pixel.Presets.Yellow;
					case 0xF: return Pixel.Presets.White; 
				}

				return Pixel.Empty;
			}

			Sprite spr;

			using (Stream stream = File.OpenRead(path))
			using (BinaryReader reader = new BinaryReader(stream))
			{
				int w = reader.ReadInt32();
				int h = reader.ReadInt32();

				spr = new Sprite(w, h);

				for (int i = 0; i < h; i++)
					for (int j = 0; j < w; j++)
						spr[j, i] = Parse(reader.ReadInt16());
			}

			return spr;
		}

19 Source : BinarySerializer.cs
with Apache License 2.0
from deveel

private static object ReadPrimitive(BinaryReader reader, bool isNull, out Type objectType) {
			var nullable = reader.ReadBoolean();
			var typeCode = (PrimitiveTypeCode) reader.ReadByte();
			objectType = SerializerUtil.GetObjectType(typeCode);

			if (nullable)
				objectType = typeof(Nullable<>).MakeGenericType(objectType);

			if (isNull)
				return null;

			switch (typeCode) {
				case PrimitiveTypeCode.Boolean:
					return reader.ReadBoolean();
				case PrimitiveTypeCode.Byte:
					return reader.ReadByte();
				case PrimitiveTypeCode.SByte:
					return reader.ReadSByte();
				case PrimitiveTypeCode.Int16:
					return reader.ReadInt16();
				case PrimitiveTypeCode.UInt16:
					return reader.ReadUInt16();
				case PrimitiveTypeCode.Int32:
					return reader.ReadInt32();
				case PrimitiveTypeCode.UInt32:
					return reader.ReadUInt32();
				case PrimitiveTypeCode.Int64:
					return reader.ReadInt64();
				case PrimitiveTypeCode.UInt64:
					return reader.ReadUInt64();
				case PrimitiveTypeCode.Single:
					return reader.ReadSingle();
				case PrimitiveTypeCode.Double:
					return reader.ReadDouble();
				case PrimitiveTypeCode.Char:
					return reader.ReadChar();
				case PrimitiveTypeCode.String:
					return reader.ReadString();
				default:
					throw new SerializationException();
			}
		}

19 Source : BinaryReaderExt.cs
with MIT License
from Dnawrkshp

public static object ReadObject(this BinaryReader reader, Type type)
        {
            if (type.GetInterface("IStreamSerializer") != null)
            {
                var result = (IStreamSerializer)Activator.CreateInstance(type);
                result.Deserialize(reader);
                return result;
            }
            else if (type.IsEnum)
                return reader.ReadObject(type.GetEnumUnderlyingType()); //Enum.Parse(type, type.GetEnumName(reader.ReadObject(type.GetEnumUnderlyingType())));
            else if (type == typeof(bool))
                return reader.ReadBoolean();
            else if (type == typeof(byte))
                return reader.ReadByte();
            else if (type == typeof(sbyte))
                return reader.ReadSByte();
            else if (type == typeof(char))
                return reader.ReadChar();
            else if (type == typeof(short))
                return reader.ReadInt16();
            else if (type == typeof(ushort))
                return reader.ReadUInt16();
            else if (type == typeof(int))
                return reader.ReadInt32();
            else if (type == typeof(uint))
                return reader.ReadUInt32();
            else if (type == typeof(long))
                return reader.ReadInt64();
            else if (type == typeof(ulong))
                return reader.ReadUInt64();
            else if (type == typeof(float))
                return reader.ReadSingle();
            else if (type == typeof(double))
                return reader.ReadDouble();
            else if (type == typeof(string))
                return reader.ReadString();

            return null;
        }

19 Source : Extensions.cs
with MIT License
from dolkensp

public static Guid? ReadGuid(this BinaryReader reader, Boolean nullable = true)
        {
            var isNull = nullable && reader.ReadInt32() == -1;

            var c = reader.ReadInt16();
            var b = reader.ReadInt16();
            var a = reader.ReadInt32();
            var k = reader.ReadByte();
            var j = reader.ReadByte();
            var i = reader.ReadByte();
            var h = reader.ReadByte();
            var g = reader.ReadByte();
            var f = reader.ReadByte();
            var e = reader.ReadByte();
            var d = reader.ReadByte();

            if (isNull) return null;

            return new Guid(a, b, c, d, e, f, g, h, i, j, k);
        }

19 Source : Extensions.cs
with MIT License
from dolkensp

public static String ReadPString(this BinaryReader binaryReader, StringSizeEnum byteLength = StringSizeEnum.Int32)
        {
            Int32 stringLength = 0;

            switch (byteLength)
            {
                case StringSizeEnum.Int8:
                    stringLength = binaryReader.ReadByte();
                    break;
                case StringSizeEnum.Int16:
                    stringLength = binaryReader.ReadInt16();
                    break;
                case StringSizeEnum.Int32:
                    stringLength = binaryReader.ReadInt32();
                    break;
                default:
                    throw new NotSupportedException("Only Int8, Int16, and Int32 string sizes are supported");
            }

            // If there is actually a string to read
            if (stringLength > 0)
            {
                return new String(binaryReader.ReadChars(stringLength));
            }

            return null;
        }

See More Examples