ReadChar() публичный метод

public ReadChar ( ) : char
Результат char
Пример #1
0
        // --- Static Methods ---
        // Loads in the team
        public static Team load(string filename, GameExt game)
        {
            // Variables
            BinaryReader	reader=	new BinaryReader(File.OpenRead(filename));
            Team	team=	new Team(game, true);
            int	size;
            int	passiveSize=	0;

            team.money=	reader.ReadInt32();
            size=	reader.ReadInt32();
            for(int i= 0; i< size; i++)
            {
                team.units.add(
                    new Unit(
                        reader.ReadString(),
                        reader.ReadString(),
                        reader.ReadString(),
                        game,
                        game.registry.get<ProfessionRegistry>().get(reader.ReadChar()+""+reader.ReadChar()+""+reader.ReadChar()+""+reader.ReadChar())
                    )
                );
                team.units.items[i].statVariance=	new BaseStats(reader.ReadUInt64());
                team.units.items[i].setExp(reader.ReadInt32());
                passiveSize=	reader.ReadInt32();
                for(int k= 0; k< passiveSize; k++)
                {
                    team.units.items[i].assignPassive(
                        team.units.items[i].decryptPassive(reader.ReadChar()),
                        k
                    );
                }
            }

            return team;
        }
Пример #2
0
        static void Main(string[] args)
        {
            using (BinaryReader b = new BinaryReader(File.Open("file.top", FileMode.Open)))
            {
                int pos = 0;
                int length = (int)b.BaseStream.Length;

                char ch0 = b.ReadChar();
                char ch1 = b.ReadChar();
                char ch2 = b.ReadChar();

                byte verr = b.ReadByte();
                /*Int32 tripCount =  b.ReadInt32();
                for (int i = 0; i < tripCount; i++)
                {
                    Int64 time = b.ReadInt64();
                    string comment = b.ReadString();
                    Int16 declination = b.ReadInt16();
                }
                pos += sizeof(char) * 3;*/
                TopFile file = new TopFile(b);

            }

            byte[] fajl = File.ReadAllBytes("file.top");

            /*          char ch0 = Convert.ToChar(fajl[0]);
            char ch1 = Convert.ToChar(fajl[1]);
            char ch2 = Convert.ToChar(fajl[2]);
            byte ver = fajl[3];*/
            //TopFile file = new TopFile(fajl, 4);
        }
Пример #3
0
 public static void GenerateDonorGenomeFromReferenceGenome(string refGenomeFile, string donorGenomeFile)
 {
     var rng = new Random();
     using (var refFile = File.OpenRead(refGenomeFile))
     using (var donorFile = File.Open(donorGenomeFile, FileMode.Create))
     {
         var reader = new BinaryReader(refFile);
         var writer = new BinaryWriter(donorFile);
         for (long i = 0; i < refFile.Length; i++)
         {
             var randomNumber = rng.NextDouble();
             if (randomNumber < SnpDensity)
             {
                 var readChar = reader.ReadChar();
                 if (readChar == 'A')
                     writer.Write('C');
                 else if (readChar == 'C')
                     writer.Write('G');
                 else if (readChar == 'G')
                     writer.Write('T');
                 else if (readChar == 'T')
                     writer.Write('A');
                 else throw new Exception();
             }
             else
             {
                 writer.Write(reader.ReadChar());
             }
         }
     }
 }
Пример #4
0
        public static void ShareMemory()
        {
            using (MemoryMappedFile mmf = MemoryMappedFile.CreateNew(MmfName, 10000))
            {
                Console.WriteLine("Process A started.");
                bool mutexCreated;
                var mutex = new Mutex(true, MmfMutex, out mutexCreated);

                using (MemoryMappedViewStream stream = mmf.CreateViewStream())
                {
                    var writer = new BinaryWriter(stream);
                    writer.Write('a');
                }
                mutex.ReleaseMutex();

                Console.WriteLine("Please start process B. Once it's done press ENTER.");
                Console.ReadLine();

                mutex.WaitOne();
                using (MemoryMappedViewStream stream = mmf.CreateViewStream())
                {
                    var reader = new BinaryReader(stream);
                    Console.WriteLine("Process A : {0}", reader.ReadChar());
                    Console.WriteLine("Process B : {0}", reader.ReadChar());
                    Console.ReadLine();
                }
                mutex.ReleaseMutex();
            }
        }
Пример #5
0
        public static SortedDictionary<string, Stream> GetEntries(string archive)
        {
            SortedDictionary<string, Stream> result = new SortedDictionary<string, Stream>();
            BinaryReader br = new BinaryReader(File.OpenRead(archive));
            StringBuilder sb = new StringBuilder();

            var magic = new String(br.ReadChars(4));
            if (magic != "BIG4" && magic != "BIGF")
            {
                throw new BigLoadException(archive + " is not a valid BIG4 File");
            }

            UInt32 filesize = br.ReadUInt32();
            UInt32 numEntries = ReadUint32LE(br);
            UInt32 offset = ReadUint32LE(br);

            for (var i = 0;i<numEntries;++i)
            {
                var entryOffset = ReadUint32LE(br);
                var entrySize = ReadUint32LE(br);

                char c = br.ReadChar();
                while(c!=0)
                {
                    sb.Append(c);
                    c = br.ReadChar();
                }
                var bs = new BigStream(br.BaseStream, entryOffset, entrySize, sb.ToString());
                result.Add(sb.ToString(), bs);
                sb.Clear();
            }

            return result;
        }
Пример #6
0
 public static BARFile Load(string filename)
 {
     if (!File.Exists(filename)) return null;
     var file = File.OpenRead(filename);
     var bar = new BARFile() {
         stream = file,
         SourceFilename = filename,
     };
     var reader = new BinaryReader(file);
     reader.Read(bar.Id = new byte[8], 0, 8);
     int unknown = reader.ReadInt32();
     int entryC = reader.ReadInt32();
     bar.DirectorySize = reader.ReadInt32();
     bar.DirectoryOffset = reader.ReadInt32();
     int unknown2 = reader.ReadInt32();
     file.Seek(bar.DirectoryOffset, SeekOrigin.Begin);
     int[] offsets = new int[entryC];
     for (int o = 0; o < offsets.Length; ++o) offsets[o] = reader.ReadInt32();
     for (int e = 0; e < entryC; ++e) {
         Entry entry = new Entry();
         entry.Offset = reader.ReadInt32();
         entry.Size = reader.ReadInt32();
         entry.Size2 = reader.ReadInt32();
         byte b0 = reader.ReadByte(),
             b1 = reader.ReadByte(),
             b2 = reader.ReadByte(),
             b3 = reader.ReadByte();
         if (b3 != 0) file.Position += 4;
         for (var c = reader.ReadChar(); c != '\0'; c = reader.ReadChar()) {
             entry.Name += c;
         }
         bar.entries.Add(entry);
     }
     return bar;
 }
Пример #7
0
        /****************************************************************************/
        public static string ReadLine(this System.IO.BinaryReader objReader)
        {
            StringBuilder sbLine = new StringBuilder();
            char          chRead = '\0';

            try
            {
                while (true)
                {
                    chRead = objReader.ReadChar();

                    if (chRead == '\r' || chRead == '\n')
                    {
                        break;
                    }

                    sbLine.Append(chRead);
                }

                if (chRead == '\r' && objReader.PeekChar() == '\n')
                {
                    objReader.ReadChar();
                }
            }
            catch (EndOfStreamException)
            {
            }

            return(sbLine.ToString());
        }
Пример #8
0
        public static string[] ReadAllLines(BinaryReader reader)
        {
            List<string> strings = new List<string>();
            StringBuilder temp = new StringBuilder();

            char lastChar = reader.ReadChar();
            // an EndOfStreamException here would propogate to the caller

            try
            {
                while (true)
                {
                    char newChar = reader.ReadChar();
                    if (lastChar == '\r' && newChar == '\n')
                    {
                        strings.Add(temp.ToString());
                    }

                    temp.Append(lastChar);
                    lastChar = newChar;
                }
            }
            catch (EndOfStreamException)
            {
                temp.Append(lastChar);
                strings.Add(temp.ToString());
                return strings.ToArray();
            }
        }
Пример #9
0
	  	public void Read(BinaryReader reader)
	  	{
	  		ID0 = reader.ReadChar();
	  		ID1 = reader.ReadChar();
	  		ID2 = reader.ReadChar();
	  		ID3 = reader.ReadChar();
	  		length = NetworkToHostOrder(reader.ReadUInt32());
	  	}
Пример #10
0
 public Int32 getShMemData(int offset = 0)
 {
     using (MemoryMappedViewStream stream = mmf.CreateViewStream())
     {
         BinaryReader reader = new BinaryReader(stream);
         for (int i = 0; i < offset; i++) reader.ReadChar();
         return reader.ReadChar();
     }
 }
Пример #11
0
        public static XmlDocument DecompressXMLDocument(Stream ms)
        {
            BinaryReader br = new BinaryReader(ms);
            StringBuilder sb = new StringBuilder();

            while (br.PeekChar() != (int)BYTE_TAGS.DEFINE_ELEMENTS_BEGIN)
            {
                br.ReadChar();
            }


            //Load elemental translations
            br.ReadChar();
            bool elem_use_short = br.ReadByte() == (byte)2;
            Dictionary<int, string> elementTrans = new Dictionary<int, string>();
            int id;
            int len;
            while (true)
            {
                if (br.ReadByte() == (int)BYTE_TAGS.DEFINE_ELEMENTS_END)
                    break;
                if (elem_use_short)
                    id = (int)br.ReadInt16();
                else
                    id = (int)br.ReadByte();
                len = br.ReadInt32();
                elementTrans.Add(id, System.Text.ASCIIEncoding.ASCII.GetString(br.ReadBytes(len)));
            }
            
            //Load attribute translations
            br.ReadByte();
            bool att_use_short = br.ReadByte() == (byte)2;
            Dictionary<int, string> attTrans = new Dictionary<int, string>();
            while (true)
            {
                if (br.ReadByte() == (byte)BYTE_TAGS.DEFINE_ATTRIBUTES_END)
                    break;
                if (att_use_short)
                    id = (int)br.ReadInt16();
                else
                    id = (int)br.ReadByte();
                len = br.ReadInt32();
                attTrans.Add(id, System.Text.ASCIIEncoding.ASCII.GetString(br.ReadBytes(len)));
            }

            //begin loading and translation of the document back to xml
            br.ReadByte();
            XmlDocument ret = new XmlDocument();
            while (br.BaseStream.Position < br.BaseStream.Length - 1)
            {
                XmlElement tmp = LoadElement(ref br, ret,att_use_short,elem_use_short,elementTrans,attTrans);
                if (tmp != null)
                    ret.AppendChild(tmp);
            }

            return ret;
        }
Пример #12
0
        public DxfBinaryReader(BinaryReader reader)
        {
            _reader = reader;

            // swallow next two characters
            var sub = reader.ReadChar();
            Debug.Assert(sub == 0x1A);
            var nul = reader.ReadChar();
            Debug.Assert(nul == 0x00);
        }
Пример #13
0
        public static DDTImage Load(Stream file)
        {
            long beg = file.Position;
            var reader = new BinaryReader(file);
            string header = "";
            for (int h = 0; h < 3; ++h) header += reader.ReadChar();
            if (header != "RTS") throw new InvalidDataException();
            int version = (int)reader.ReadChar() - (int)'0';
            if (version == 3) {
                var img = new DDTImage();
                var serializer = new SerialReader(new BinaryReader(file));
                SerializeHeader(ref img.Header, serializer);

                int numColors = (img.Palette != null ? img.Palette.Length : 0);
                int[] paletteOffs = new int[5];
                if (img.Header.Format == ImageHeader.FormatE.Palette) {
                    // TODO: paletteOffs[img.Header.AlphaBits] = palette offset
                    serializer.Serialize(ref numColors);
                    int unknown02 = 0;
                    int palette15Off = 0;
                    serializer.Serialize(ref unknown02);
                    serializer.Serialize(ref paletteOffs[0]);       //16
                    serializer.Serialize(ref palette15Off);
                    serializer.Serialize(ref paletteOffs[1]);       //15b
                    serializer.Serialize(ref paletteOffs[4]);       //12
                }

                List<Tuple<int, int>> images = new List<Tuple<int, int>>();
                for (int l = 0; l < img.Header.MipLevels; ++l) {
                    int off = reader.ReadInt32();
                    int len = reader.ReadInt32();
                    images.Add(new Tuple<int,int>(off, len));
                }

                if (img.Header.Format == ImageHeader.FormatE.Palette) {
                    file.Seek(beg + paletteOffs[img.Header.AlphaBits], SeekOrigin.Begin);
                    byte[] paletteData = new byte[numColors * 2];
                    file.Read(paletteData, 0, paletteData.Length);

                    img.Palette = new Pixel[numColors];
                    switch (img.Header.AlphaBits) {
                        case 0: Convert565ToRGB(paletteData, 0, img.Palette); break;
                        case 1: Convert555ToRGB(paletteData, 0, img.Palette); break;
                        case 4: Convert444ToRGB(paletteData, 0, img.Palette); break;
                    }
                }

                file.Seek(beg + images[0].Item1, SeekOrigin.Begin);
                byte[] bytes = new byte[images[0].Item2];
                reader.Read(bytes, 0, bytes.Length);
                img.PixelData = bytes;
                return img;
            }
            return null;
        }
Пример #14
0
        /// <summary>
        /// Reads the specified PGM stream and returns a Bitmap.
        /// </summary>
        /// <param name="stream">The stream.</param>
        /// <returns></returns>
        /// <exception cref="BadImageFormatException">PGM Magic Number not found.</exception>
        public static Bitmap Read(Stream stream)
        {
            using (var reader = new BinaryReader(stream, Encoding.ASCII))
            {
                if ((reader.ReadChar() == 'P' && reader.ReadChar() == '5') == false)
                    throw new BadImageFormatException("PGM Magic Number not found.");

                // Read onew whitespace character
                reader.ReadChar();

                // Get basic PGM format properties
                var parseBuffer = new StringBuilder();
                var pgmWidth = ReadInteger(reader, parseBuffer);
                var pgmHeight = ReadInteger(reader, parseBuffer);
                var grayscaleLevels = ReadInteger(reader, parseBuffer);
                var isTwoByteLevel = (grayscaleLevels > 255);

                // Create the bitmap and assign the 8bpp Indexed palette
                var bmp = new Bitmap(pgmWidth, pgmHeight, PixelFormat.Format8bppIndexed);
                bmp.Palette = GrayscalePalette;

                // Create the target lockbits
                var bitmapData = bmp.LockBits(new Rectangle(0, 0, pgmWidth, pgmHeight), ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
                var rowLengthOffset = bitmapData.Stride - bitmapData.Width;
                var dataLength = bitmapData.Stride * bitmapData.Height;
                var pixelData = new byte[dataLength];

                var pixelDataIndex = 0;
                var currentPixelValue = (byte)0;

                for (int rowIndex = 0; rowIndex < pgmHeight; rowIndex++)
                {
                    for (int columnIndex = 0; columnIndex < pgmWidth; columnIndex++)
                    {
                        currentPixelValue = reader.ReadByte();
                        if (isTwoByteLevel)
                            currentPixelValue = (byte)(((double)((currentPixelValue << 8) + reader.ReadByte()) / grayscaleLevels) * 255.0);

                        pixelData[pixelDataIndex] = currentPixelValue;
                        pixelDataIndex++;
                    }

                    pixelDataIndex += rowLengthOffset;
                }

                // Use a fast copy mechanism to write the data to the bitmap
                System.Runtime.InteropServices.Marshal.Copy(pixelData, 0, bitmapData.Scan0, dataLength);

                // Release the write lock on the bits.
                bmp.UnlockBits(bitmapData);

                return bmp;
            }
        }
Пример #15
0
 public static string ReadCString(BinaryReader rdr)
 {
     string ret = "";
     char c = rdr.ReadChar();
     while (c != '\0')
     {
         ret += c;
         c = rdr.ReadChar();
     }
     return "";
 }
Пример #16
0
 private string ReadLine(BinaryReader binReader)
 {
     StringBuilder result = new StringBuilder();
     char lastChar = binReader.ReadChar();
     while (lastChar != '\n')
     {
         result.Append(lastChar);
         lastChar = binReader.ReadChar();
     }
     return result.ToString();
 }
Пример #17
0
 public static string ReadString(BinaryReader stream)
 {
     string r = "";
     char c = stream.ReadChar();
     while (c != 0xFF)
     {
         r += c;
         c = stream.ReadChar();
     }
     return r;
 }
        public byte[] ExtractAudio(Stream stream)
        {
            stream.Position = 0;

            var reader = new BinaryReader(stream);

            // Is stream a Flash Video stream
            if (reader.ReadChar() != 'F' || reader.ReadChar() != 'L' || reader.ReadChar() != 'V')
                throw new IOException("The file is not a FLV file.");

            // Is audio stream exists in the video stream
            var version = reader.ReadByte();
            var exists = reader.ReadByte();

            if ((exists != 5) && (exists != 4))
                throw new IOException("No Audio Stream");

            reader.ReadInt32(); // data offset of header. ignoring

            var output = new List<byte>();

            while (true)
            {
                try
                {
                    reader.ReadInt32(); // PreviousTagSize0 skipping

                    var tagType = reader.ReadByte();

                    while (tagType != 8)
                    {
                        var skip = ReadNext3Bytes(reader) + 11;
                        reader.BaseStream.Position += skip;

                        tagType = reader.ReadByte();
                    }

                    var DataSize = ReadNext3Bytes(reader);

                    reader.ReadInt32(); //skip timestamps 
                    ReadNext3Bytes(reader); // skip streamID
                    reader.ReadByte(); // skip audio header

                    for (int i = 0; i < DataSize - 1; i++)
                        output.Add(reader.ReadByte());
                }
                catch
                {
                    break;
                }
            }

            return output.ToArray();
        }
Пример #19
0
 protected override void OnSetData(BinaryReader reader)
 {
     this.Data.CommandId = reader.ReadInt32();
     this.Data.Text = reader.ReadString();
     this.Data.TransactTime = new DateTime(reader.ReadInt64());
     this.Data.CxlRejReason = reader.ReadInt32();
     this.Data.CxlRejResponseTo = reader.ReadChar();
     this.Data.OrderID = reader.ReadString();
     this.Data.OrdStatus = reader.ReadChar();
     this.Data.OrigClOrdID = reader.ReadString();
     this.Data.ClOrdID = reader.ReadString();
 }
Пример #20
0
        static void Main(string[] args)
        {
            var values = new List<Value>();

            using (var strm = File.OpenRead(args[0]))
            {
                using (var rdr = new BinaryReader(strm))
                {
                    if (rdr.ReadChar() != 'S' || rdr.ReadChar() != 'T' || rdr.ReadChar() != 'R' || rdr.ReadChar() != 'M')
                        throw new Exception("Invalid header");
                    var tableCount = rdr.ReadInt32();
                    var valueCount = rdr.ReadInt32();
                    var charCount = rdr.ReadInt32();
                    //ulong sig = rdr.ReadUInt64();

                    strm.Seek(-charCount, SeekOrigin.End);

                    var chars = rdr.ReadBytes(charCount);

                    strm.Seek(24 + tableCount * TABLE_SIZE, SeekOrigin.Begin);

                    for (var i = 0; i < valueCount; i++)
                    {
                        var strOff = rdr.ReadInt32();
                        //int unused1 = rdr.ReadInt32();
                        //int unused2 = rdr.ReadInt32();
                        //int unused3 = rdr.ReadInt32();
                        var rva = rdr.ReadInt64();
                        values.Add(new Value(FromByteArray(chars, strOff), (ulong)rva));
                    }

                    values.Sort((a, b) => Comparer<string>.Default.Compare(a.Key, b.Key));

                    Console.WriteLine($"We loaded {values.Count} symbols!");
                }
            }

            using (var strm = File.OpenWrite("symbol_map.txt"))
            {
                using (var wtr = new StreamWriter(strm))
                {
                    for (var i = 0; i < values.Count; i++)
                    {
                        var value = values[i];
                        wtr.WriteLine($"0x{value.RVA:X} {value.Key}");
                    }
                    wtr.Flush();
                }
            }

            Console.ReadKey();
            Console.WriteLine("Done");
        }
Пример #21
0
        public static PgmImg ReadPgmImg(string filePath)
        {
            using (FileStream fs = new FileStream(filePath, FileMode.Open))
            {
                using (BinaryReader reader = new BinaryReader(fs, Encoding.ASCII))
                {
                    if (reader.ReadChar() == 'P' && reader.ReadChar() == '5')
                    {
                        reader.ReadChar();
                        int width = 0;
                        int height = 0;
                        int level = 0;
                        bool two = false;

                        width = ReadNumber(reader);
                        height = ReadNumber(reader);
                        level = ReadNumber(reader);
                        two = (level > 255);

                        var mat = new PgmImg(width, height);

                        for (int i = 0; i < height; i++)
                        {
                            for (int j = 0; j < width; j++)
                            {
                                byte v;
                                if (two)
                                {
                                    v = (byte)(((double)((reader.ReadByte() << 8) + reader.ReadByte()) / level) * 255.0);
                                }
                                else
                                {
                                    v = reader.ReadByte();
                                }

                                mat[j, i] = v;

                            }
                        }

                        return mat;
                    }
                    else
                    {
                        throw new InvalidOperationException("Is not a PGM file");
                    }

                }
            }
        }
Пример #22
0
        public override void Deserialise(Stream xiInStream, int xiLength)
        {
            BinaryReader lReader = new BinaryReader(xiInStream);
              string lName = "";
              char lChar = lReader.ReadChar();
              while (lChar != 0)
              {
            lName += lChar;
            lChar = lReader.ReadChar();
              }

              mName = lName;
              return;
        }
Пример #23
0
 public string ReadCString(BinaryReader br)
 {
     var offset = br.ReadUInt32();
     var oldPos = br.BaseStream.Position;
     br.BaseStream.Seek(offset, SeekOrigin.Begin);
     StringBuilder sb = new StringBuilder();
     char c = br.ReadChar();
     while (c!=0)
     {
         sb.Append(c);
         c = br.ReadChar();
     }
     br.BaseStream.Seek(oldPos, SeekOrigin.Begin);
     return sb.ToString();
 }
Пример #24
0
        public string readStringTillZero(BinaryReader reader)
        {
            char[] work = new char[MAX_LENGTH];

            int i = 0;

            char c = reader.ReadChar();
            while (c != Convert.ToChar(0x00))
            {
                work[i++] = c;
                c = reader.ReadChar();
            }
            return new string(work, 0, i);

        }
        /// <summary>
        /// Creates a new instance of the DirectoryInfo struct and
        /// reads the information from the VPK BinaryReader.
        /// </summary>
        /// <param name="VPKReader">Stream to read directory information from.</param>
        internal DirectoryInfo(BinaryReader VPKReader)
        {
            // The stream is located at the end of the file, minus the size of the struct.
            VPKReader.BaseStream.Seek(-9, SeekOrigin.End);

            FileCount = VPKReader.ReadInt32();
            DirectoryOffset = (UInt32)VPKReader.ReadInt32();
            char type = VPKReader.ReadChar();

            switch (type)
            {
                case (char)DirectoryInfoType.PATHS_ONLY:
                    Type = DirectoryInfoType.PATHS_ONLY;
                    break;

                case (char)DirectoryInfoType.PATHS_AND_FILES:
                    Type = DirectoryInfoType.PATHS_AND_FILES;
                    break;

                default:
                    // Invalid, but Type isn't really used so we'll silenty ignore it.
                    Type = DirectoryInfoType.PATHS_AND_FILES;
                    break;
            }
        }
Пример #26
0
        private void ValidateDisposedExceptions(BinaryReader binaryReader)
        {
            byte[] byteBuffer = new byte[10];
            char[] charBuffer = new char[10];

            Assert.Throws<ObjectDisposedException>(() => binaryReader.PeekChar());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.Read());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.Read(byteBuffer, 0, 1));
            Assert.Throws<ObjectDisposedException>(() => binaryReader.Read(charBuffer, 0, 1));
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadBoolean());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadByte());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadBytes(1));
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadChar());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadChars(1));
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadDecimal());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadDouble());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadInt16());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadInt32());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadInt64());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadSByte());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadSingle());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadString());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadUInt16());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadUInt32());
            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadUInt64());
        }
        public override void FromStream(Stream stream)
        {
            base.FromStream(stream);

            long endOffset = (stream.Position + Header.Size + 1) & ~0x1;

            BinaryReader reader = new BinaryReader(stream);

            uint symbolCount = NativeUtils.SwapEndian(reader.ReadUInt32());

            SymbolsOffsets = new SymbolOffset[symbolCount];

            for (uint i = 0; i < symbolCount; ++i)
            {
                SymbolsOffsets[i].Offset = reader.ReadUInt32();
            }

            StringBuilder sb = new StringBuilder(1024);
            for (uint i = 0; i < symbolCount; ++i)
            {
                char c;
                while ((c = reader.ReadChar()) != 0)
                {
                    sb.Append(c);
                }

                SymbolsOffsets[i].Name = sb.ToString();
                sb.Clear();
            }

            stream.Seek(endOffset, SeekOrigin.Begin);
        }
Пример #28
0
        public void createTree(long[] array) {
            byte[] buffer = new byte[8];
            using (MemoryStream memory = new MemoryStream(buffer, true)) {
                for (int i = 0; i < array.Length; i++) {
                    using (BinaryWriter writer = new BinaryWriter(memory)) {
                        writer.Write(array[i]);
                    }

                    memory.Position = 0;
                    using (BinaryReader reader = new BinaryReader(memory)) {
                        while (buffer[memory.Position] == 0 && buffer[memory.Position + 1] == 0) {
                            reader.ReadChar();
                        }

                        allocateInTree(reader.ReadBytes((int) memory.Length - (int) memory.Position), root, buffer[i]);
                    }
                }
            }
//            ByteBuffer bb = ByteBuffer.allocate(8);
//        for (long item: array) {
//
//            bb.putLong(item);
//            bb.flip();
//
//            while (bb.array()[bb.position()] == 0 && bb.array()[bb.position()+1] == 0) {
//                bb.getChar();
//            }
//
//            allocateInTree(bb, root, item);
//            bb.clear();
//        }
    }
Пример #29
0
            public static void Load()
            {
                var local = GetData("UFSJ.S.uscx");
                try
                {
                    using (var i = new BinaryReader(File.OpenRead(local)))
                    {
                        if (i.ReadChar() == 'U')
                        {
                            OnTopMost = i.ReadBoolean(); //OnTopMost
                            SilentProgress = i.ReadBoolean(); //SilentProgress
                            ShowSummary = i.ReadBoolean(); //ShowSummary
                            AssociateExt = i.ReadBoolean(); //AssociateExt
                            StartHide = i.ReadBoolean(); //StartHide
                            ShellMenus = i.ReadBoolean(); //ShellMenus
                            SettingMode = i.ReadInt16(); //SettingMode
                            Theme = i.ReadString(); //ColorScheme
                            Language = i.ReadString(); //Language
                            Formats = i.ReadString(); //Formats
                            Position = new Point(i.ReadInt32(), i.ReadInt32());
                        }
                    }
                }
                catch (Exception)
                {
                    SaveDefault();
                    Load();
                }

            }
Пример #30
0
 public static void ReadFrom(BinaryReader reader, FIXGroup group)
 {
     int num = reader.ReadInt32();
     for (int index = 0; index < num; ++index)
     {
         int tag = reader.ReadInt32();
         FIXType fixType = EFIXFieldTypes.GetFIXType(tag);
         switch (fixType)
         {
             case FIXType.Bool:
                 group.AddBoolField(tag, reader.ReadBoolean());
                 break;
             case FIXType.Int:
                 group.AddIntField(tag, reader.ReadInt32());
                 break;
             case FIXType.Double:
                 group.AddDoubleField(tag, reader.ReadDouble());
                 break;
             case FIXType.Char:
                 group.AddCharField(tag, reader.ReadChar());
                 break;
             case FIXType.String:
                 group.AddStringField(tag, reader.ReadString());
                 break;
             case FIXType.DateTime:
                 group.AddDateTimeField(tag, new DateTime(reader.ReadInt64()));
                 break;
             default:
                 throw new ArgumentException("" + fixType.ToString());
         }
     }
 }
Пример #31
0
 private void ReadName(BinaryReader br)
 {
     StringBuilder sb = new StringBuilder();
     char c;
     while ((c = br.ReadChar()) > 0) sb.Append(c);
     _name = sb.ToString();
 }
 /// <summary>
 /// Reads an object of type <see cref="char"/> from the current stream
 /// and advances the stream position.
 /// This method reads directly from the underlying stream.
 /// </summary>
 /// <returns>object read from the stream</returns>
 public char ReadChar()
 {
     if (reader == null)
     {
         reader = new BinaryReader(stream);
     }
     return(reader.ReadChar());
 }
    static int ReadChar(IntPtr L)
    {
        LuaScriptMgr.CheckArgsCount(L, 1);
        System.IO.BinaryReader obj = (System.IO.BinaryReader)LuaScriptMgr.GetNetObjectSelf(L, 1, "System.IO.BinaryReader");
        char o = obj.ReadChar();

        LuaScriptMgr.Push(L, o);
        return(1);
    }
Пример #34
0
        public Material(System.IO.BinaryReader br)
        {
            m_ambientColor = new Vec4(br);
            m_diffuseColor = new Vec4(br);
            m_name         = br.ReadString();
            bool isOpacityMapNull = br.ReadBoolean();

            if (isOpacityMapNull)
            {
                this.m_opacityMap = null;
            }
            else
            {
                this.m_opacityMap = MaterialMap.Load(br);
            }

            this.m_shininess     = (float)br.ReadDouble();
            this.m_specularColor = new Vec4(br);
            int count = br.ReadInt32();

            if (count > 0)
            {
                for (int i = 0; i < count; ++i)
                {
                    AddMaterialMap(MaterialMap.Load(br));
                }
            }

            this.Transparency = (float)br.ReadDouble();
            this.m_twoSided   = br.ReadBoolean();
            this.m_scale      = (float)br.ReadDouble();
            if (this.m_scale != 1)
            {
                this.hasTexTransform = true;
            }
            if (br.ReadBoolean())
            {
                remapUV    = new Vec2[2];
                remapUV[0] = Vec2.Load(br);
                remapUV[1] = Vec2.Load(br);
            }
            else
            {
                remapUV = null;
            }
            if (br.PeekChar() == '~')
            {
                br.ReadChar();
                count = br.ReadInt32();
                for (int i = 0; i < count; ++i)
                {
                    AddShader(Shader.Load(br));
                }
            }
        }
Пример #35
0
        public static string ReadNullTerminatedString(System.IO.BinaryReader stream)
        {
            string str = string.Empty;
            char   ch;

            while ((int)(ch = stream.ReadChar()) != 0)
            {
                str = str + ch;
            }
            return(str);
        }
Пример #36
0
        private string ReadNullTerminatedString(System.IO.BinaryReader stream)
        {
            string str = "";
            char   ch;

            while ((int)(ch = stream.ReadChar()) != 0)
            {
                str = str + ch;
            }
            return(str);
        }
        public static char[] ReadNullTerminatedString(this System.IO.BinaryReader stream)
        {
            string str = "";
            char   ch;

            while ((int)(ch = stream.ReadChar()) != 0)
            {
                str = str + ch;
            }

            return(str.ToCharArray());
        }
Пример #38
0
        private static string ReadString(System.IO.BinaryReader reader)
        {
            int i       = 0;
            var cbuffer = new char[16];

            do
            {
                cbuffer[i] = reader.ReadChar();
            }while (cbuffer[i] != '\0' && ++i < cbuffer.Length);

            return(new string(cbuffer).TrimEnd(new char[] { '\0' }));
        }
Пример #39
0
 static public int ReadChar(IntPtr l)
 {
     try {
         System.IO.BinaryReader self = (System.IO.BinaryReader)checkSelf(l);
         var ret = self.ReadChar();
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Пример #40
0
        public static string Read(System.IO.BinaryReader reader)
        {
            string str = string.Empty;

            int length = reader.ReadInt32();

            for (int i = 0; i < length; ++i)
            {
                str += reader.ReadChar();
            }

            return(str);
        }
Пример #41
0
        private string UnserializeStringZero(System.IO.BinaryReader r)
        {
            string s = "";

            while (r.BaseStream.Position < r.BaseStream.Length)
            {
                char b = r.ReadChar();
                if (b == 0)
                {
                    break;
                }
                s += b;
            }
            return(s);
        }
Пример #42
0
        public static object LoadKey(this DbColumnType keyType, io.BinaryReader reader)
        {
            switch (keyType)
            {
            case DbColumnType.Char:
                //
                return(reader.ReadChar());

            case DbColumnType.Byte:
                //
                return(reader.ReadByte());

            case DbColumnType.Int16:
                //
                return(reader.ReadInt16());

            case DbColumnType.Int32:
                //
                return(reader.ReadInt32());

            case DbColumnType.Int64:
                //
                return(reader.ReadInt64());

            case DbColumnType.Single:
                //
                return(reader.ReadSingle());

            case DbColumnType.Double:
                //
                return(reader.ReadDouble());

            case DbColumnType.Decimal:
                //
                return(reader.ReadDecimal());

            case DbColumnType.String:
                //
                var length = reader.ReadByte();
                var chars  = reader.ReadChars(length);
                return(new string(chars));

            default:
                return(null);
            }
        }
Пример #43
0
        static string ReadNullTerminatedString(this System.IO.BinaryReader stream)
        {
            string str = "";
            char   ch;

            try
            {
                while ((int)(ch = stream.ReadChar()) != 0)
                {
                    str = str + ch;
                }
            }
            catch (Exception ex)
            {
            }


            return(str);
        }
        private void btnRead_Click(object sender, RoutedEventArgs e)
        {
            listFile.Items.Clear();
            try
            {
                if (File.Exists(filePath))
                {
                    using (System.IO.BinaryReader br = new System.IO.BinaryReader(File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite), Encoding.UTF8))
                    {
                        StreamReader sr = new StreamReader(filePath);

                        while (!sr.EndOfStream)
                        {
                            byte[] array = new byte[100];
                            int    i     = 0;
                            char   temp;
                            do
                            {
                                temp     = br.ReadChar();
                                array[i] = Convert.ToByte(temp);
                                i++;
                            } while (temp != '\n');

                            Array.Resize(ref array, i - 3);
                            Array.Reverse(array);
                            Array.Resize(ref array, i - 4);
                            Array.Reverse(array);

                            listFile.Items.Add(Encoding.UTF8.GetString(array));
                            sr.ReadLine();
                        }
                        sr.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("Reading Error :" + ex.Message + "\nSource :" + ex.InnerException);
            }
        }
Пример #45
0
 //UPGRADE_TODO: Class 'java.io.DataInputStream' was converted to 'System.IO.BinaryReader' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javaioDataInputStream'"
 public static char readChar(System.IO.BinaryReader in_Renamed)
 {
     return(in_Renamed.ReadChar());
 }
Пример #46
0
        public override object[] ReadDbRecord(int offset)
        {
            var mainMask = Table.RowMask;
            var bytes    = Table.RowMaskLength;

            //point to record offset
            reader.BaseStream.Position = offset;

            //read record
            var buffer = new byte[sizeof(UInt64)];

            reader.Read(buffer, 0, bytes);
            var recordMask = BitConverter.ToUInt64(buffer, 0);
            //copy main
            var bitMask     = mainMask;
            var columnCount = Table.Count;

            //create record according to table columns
            var dbRecord = new object[columnCount];

            for (var i = 0; i < columnCount; i++)
            {
                var colType = Table.ColumnTypes[i];

                if ((recordMask & bitMask) == 0)
                {
                    //not null value
                    object value = null;

                    switch (colType)
                    {
                    case DbColumnType.Char:
                        value = reader.ReadChar();
                        break;

                    case DbColumnType.Byte:
                        value = reader.ReadByte();
                        break;

                    case DbColumnType.Int16:
                        value = reader.ReadInt16();
                        break;

                    case DbColumnType.Int32:
                        value = reader.ReadInt32();
                        break;

                    case DbColumnType.Int64:
                        value = reader.ReadInt64();
                        break;

                    case DbColumnType.Single:
                        value = reader.ReadSingle();
                        break;

                    case DbColumnType.Double:
                        value = reader.ReadDouble();
                        break;

                    case DbColumnType.Decimal:
                        value = reader.ReadDecimal();
                        break;

                    case DbColumnType.String:
                        value = reader.ReadString();
                        break;

                    default:
                        throw new ArgumentException($"invalid column type: {colType}");
                    }
                    //store value in right spot
                    dbRecord[i] = value;
                }
                bitMask >>= 1;
            }
            //
            return(dbRecord);
        }
Пример #47
0
        public SkinnedModel loadFromFile(string filename)
        {
            Info.print("Loading IQM model {0}", filename);

            if (File.Exists(filename) == false)
            {
                Warn.print("Cannot find file {0}", filename);
                return(null);
            }

            V3N3T2B4W4[] vertexData;
            ushort[]     triangleIndexes;

            IQMHeader myHeader;

            byte[]        myTexts;
            List <String> myComments = new List <String>();

            iqmvertexarray[] myVertArrays;
            iqmjoint[]       myJoints;
            iqmpose[]        myPoses;
            iqmanim[]        myAnimataions;
            iqmbounds[]      myBounds;
            iqmmesh[]        meshData;
            ushort[]         myFrameData;

            SkinnedModel sm = new SkinnedModel();

            System.IO.FileStream   stream = null;
            System.IO.BinaryReader reader = null;
            try
            {
                // Open the specified file as a stream and create a reader
                stream = new System.IO.FileStream(filename, FileMode.Open, FileAccess.Read);
                reader = new System.IO.BinaryReader(stream);

                myHeader.magic   = reader.ReadChars(16);
                myHeader.version = reader.ReadUInt32();
                if (myHeader.version != 2)
                {
                    return(null);
                }
                myHeader.filesize          = reader.ReadUInt32();
                myHeader.flags             = reader.ReadUInt32();
                myHeader.num_text          = reader.ReadUInt32();
                myHeader.ofs_text          = reader.ReadUInt32();
                myHeader.num_meshes        = reader.ReadUInt32();
                myHeader.ofs_meshes        = reader.ReadUInt32();
                myHeader.num_vertexarrays  = reader.ReadUInt32();
                myHeader.num_vertexes      = reader.ReadUInt32();
                myHeader.ofs_vertexarrays  = reader.ReadUInt32();
                myHeader.num_triangles     = reader.ReadUInt32();
                myHeader.ofs_triangles     = reader.ReadUInt32();
                myHeader.ofs_adjacency     = reader.ReadUInt32();
                myHeader.num_joints        = reader.ReadUInt32();
                myHeader.ofs_joints        = reader.ReadUInt32();
                myHeader.num_poses         = reader.ReadUInt32();
                myHeader.ofs_poses         = reader.ReadUInt32();
                myHeader.num_anims         = reader.ReadUInt32();
                myHeader.ofs_anims         = reader.ReadUInt32();
                myHeader.num_frames        = reader.ReadUInt32();
                myHeader.num_framechannels = reader.ReadUInt32();
                myHeader.ofs_frames        = reader.ReadUInt32();
                myHeader.ofs_bounds        = reader.ReadUInt32();
                myHeader.num_comment       = reader.ReadUInt32();
                myHeader.ofs_comment       = reader.ReadUInt32();
                myHeader.num_extensions    = reader.ReadUInt32();
                myHeader.ofs_extensions    = reader.ReadUInt32();

                boneCount = (int)myHeader.num_joints;

                //read text
                myTexts = new byte[myHeader.num_text];
                stream.Seek(myHeader.ofs_text, SeekOrigin.Begin);
                for (int i = 0; i < myHeader.num_text; i++)
                {
                    myTexts[i] = reader.ReadByte();
                }

                #region read geometry

                //create geometry fields
                for (int m = 0; m < myHeader.num_meshes; m++)
                {
                    sm.myMeshes.Add(new Mesh());
                }

                //read the mesh data
                meshData = new iqmmesh[myHeader.num_meshes];
                stream.Seek(myHeader.ofs_meshes, SeekOrigin.Begin);
                for (int i = 0; i < myHeader.num_meshes; i++)
                {
                    iqmmesh temp = new iqmmesh();
                    UInt32  n    = reader.ReadUInt32();
                    temp.name     = readNullTerminated(myTexts, n);
                    n             = reader.ReadUInt32();
                    temp.material = readNullTerminated(myTexts, n);
                    String fn = System.IO.Path.GetFileName(temp.material);
                    fn = System.IO.Path.ChangeExtension(fn, ".png");

                    String dir = System.IO.Path.GetDirectoryName(filename);
                    fn = System.IO.Path.Combine(dir, fn);

                    TextureDescriptor td  = new TextureDescriptor(fn);
                    Texture           tex = myResourceManager.getResource(td) as Texture;
                    Material          m   = new Material(temp.material);
                    m.addAttribute(new TextureAttribute("diffuseMap", tex));
                    m.myFeatures |= Material.Feature.Lighting;
                    m.myFeatures |= Material.Feature.DiffuseMap;

                    sm.myMeshes[i].material = m;

                    temp.first_vertex   = reader.ReadUInt32();
                    temp.num_vertexes   = reader.ReadUInt32();
                    temp.first_triangle = reader.ReadUInt32();
                    temp.num_triangles  = reader.ReadUInt32();
                    meshData[i]         = temp;
                }

                //read vertex arrays
                myVertArrays = new iqmvertexarray[myHeader.num_vertexarrays];
                stream.Seek(myHeader.ofs_vertexarrays, SeekOrigin.Begin);
                for (int i = 0; i < myHeader.num_vertexarrays; i++)
                {
                    iqmvertexarray temp = new iqmvertexarray();
                    temp.type       = (VertexArrayType)reader.ReadUInt32();
                    temp.flags      = reader.ReadUInt32();
                    temp.format     = (VertexArrayFormat)reader.ReadUInt32();
                    temp.size       = reader.ReadUInt32();
                    temp.offset     = reader.ReadUInt32();
                    myVertArrays[i] = temp;
                }

                //read the vertex data
                vertexData = new V3N3T2B4W4[myHeader.num_vertexes];
                for (int i = 0; i < myHeader.num_vertexarrays; i++)
                {
                    iqmvertexarray va = myVertArrays[i];
                    switch (va.type)
                    {
                    case VertexArrayType.IQM_POSITION:
                    {
                        stream.Seek(va.offset, SeekOrigin.Begin);
                        for (int j = 0; j < myHeader.num_vertexes; j++)
                        {
                            Vector3 temp = new Vector3();
                            temp.X = reader.ReadSingle();
                            temp.Y = reader.ReadSingle();
                            temp.Z = reader.ReadSingle();
                            vertexData[j].Position = temp;
                        }
                        break;
                    }

                    case VertexArrayType.IQM_TEXCOORD:
                    {
                        stream.Seek(va.offset, SeekOrigin.Begin);
                        for (int j = 0; j < myHeader.num_vertexes; j++)
                        {
                            Vector2 temp = new Vector2();
                            temp.X = reader.ReadSingle();
                            temp.Y = reader.ReadSingle();
                            vertexData[j].TexCoord = temp;
                        }
                        break;
                    }

                    case VertexArrayType.IQM_NORMAL:
                    {
                        stream.Seek(va.offset, SeekOrigin.Begin);
                        for (int j = 0; j < myHeader.num_vertexes; j++)
                        {
                            Vector3 temp = new Vector3();
                            temp.X = reader.ReadSingle();
                            temp.Y = reader.ReadSingle();
                            temp.Z = reader.ReadSingle();
                            vertexData[j].Normal = temp;
                        }
                        break;
                    }

                    case VertexArrayType.IQM_BLENDINDEXES:
                    {
                        stream.Seek(va.offset, SeekOrigin.Begin);
                        for (int j = 0; j < myHeader.num_vertexes; j++)
                        {
                            Vector4 temp = new Vector4();
                            temp.X = (float)reader.ReadByte();
                            temp.Y = (float)reader.ReadByte();
                            temp.Z = (float)reader.ReadByte();
                            temp.W = (float)reader.ReadByte();
                            vertexData[j].BoneId = temp;
                        }
                        break;
                    }

                    case VertexArrayType.IQM_BLENDWEIGHTS:
                    {
                        stream.Seek(va.offset, SeekOrigin.Begin);
                        for (int j = 0; j < myHeader.num_vertexes; j++)
                        {
                            Vector4 temp = new Vector4();
                            temp.X = ((float)reader.ReadByte()) / 255.0f;
                            temp.Y = ((float)reader.ReadByte()) / 255.0f;
                            temp.Z = ((float)reader.ReadByte()) / 255.0f;
                            temp.W = ((float)reader.ReadByte()) / 255.0f;
                            vertexData[j].BoneWeight = temp;
                        }
                        break;
                    }
                    }
                }

                //read triangles indexes
                triangleIndexes = new ushort[myHeader.num_triangles * 3];
                stream.Seek(myHeader.ofs_triangles, SeekOrigin.Begin);
                for (int i = 0; i < myHeader.num_triangles * 3; i++)
                {
                    triangleIndexes[i] = (ushort)reader.ReadUInt32();
                }
                #endregion

                #region read animation data
                //read joints
                myJoints = new iqmjoint[myHeader.num_joints];
                stream.Seek(myHeader.ofs_joints, SeekOrigin.Begin);
                for (int i = 0; i < myHeader.num_joints; i++)
                {
                    iqmjoint temp = new iqmjoint();
                    UInt32   n    = reader.ReadUInt32();
                    temp.name        = readNullTerminated(myTexts, n);
                    temp.parent      = reader.ReadInt32();
                    temp.translate   = new Vector3();
                    temp.translate.X = reader.ReadSingle();
                    temp.translate.Y = reader.ReadSingle();
                    temp.translate.Z = reader.ReadSingle();
                    temp.rotate      = new Quaternion();
                    temp.rotate.X    = reader.ReadSingle();
                    temp.rotate.Y    = reader.ReadSingle();
                    temp.rotate.Z    = reader.ReadSingle();
                    temp.rotate.W    = reader.ReadSingle();
                    temp.rotate.Normalize();
                    temp.scale   = new Vector3();
                    temp.scale.X = reader.ReadSingle();
                    temp.scale.Y = reader.ReadSingle();
                    temp.scale.Z = reader.ReadSingle();
                    myJoints[i]  = temp;
                }

                //read poses
                myPoses = new iqmpose[myHeader.num_poses];
                stream.Seek(myHeader.ofs_poses, SeekOrigin.Begin);
                for (int i = 0; i < myHeader.num_poses; i++)
                {
                    iqmpose temp = new iqmpose();
                    temp.parent      = reader.ReadInt32();
                    temp.channelmask = reader.ReadUInt32();

                    temp.channeloffset = new float[10];
                    for (int j = 0; j < 10; j++)
                    {
                        temp.channeloffset[j] = reader.ReadSingle();
                    }

                    temp.channelscale = new float[10];
                    for (int j = 0; j < 10; j++)
                    {
                        temp.channelscale[j] = reader.ReadSingle();
                    }

                    myPoses[i] = temp;
                }

                //read animations
                myAnimataions = new iqmanim[myHeader.num_anims];
                stream.Seek(myHeader.ofs_anims, SeekOrigin.Begin);
                for (int i = 0; i < myHeader.num_anims; i++)
                {
                    iqmanim temp = new iqmanim();
                    UInt32  n    = reader.ReadUInt32();
                    temp.name        = readNullTerminated(myTexts, n);
                    temp.first_frame = reader.ReadUInt32();
                    temp.num_frames  = reader.ReadUInt32();
                    temp.framerate   = reader.ReadSingle();
                    temp.flags       = reader.ReadUInt32();
                    myAnimataions[i] = temp;


                    Animation a = new Animation();
                    a.name = temp.name;
                    a.fps  = temp.framerate;
                    a.loop = true;
                    sm.animations.Add(a.name, a);
                }

                //read frame data
                myFrameData = new ushort[myHeader.num_frames * myHeader.num_framechannels];
                stream.Seek(myHeader.ofs_frames, SeekOrigin.Begin);
                for (int i = 0; i < myHeader.num_frames * myHeader.num_framechannels; i++)
                {
                    myFrameData[i] = reader.ReadUInt16();
                }

                #endregion

                //read bounds
                myBounds = new iqmbounds[myHeader.num_frames];
                stream.Seek(myHeader.ofs_bounds, SeekOrigin.Begin);
                for (int i = 0; i < myHeader.num_frames; i++)
                {
                    iqmbounds temp = new iqmbounds();
                    temp.bbmins    = new float[3];
                    temp.bbmaxs    = new float[3];
                    temp.bbmins[0] = reader.ReadSingle();
                    temp.bbmins[1] = reader.ReadSingle();
                    temp.bbmins[2] = reader.ReadSingle();
                    temp.bbmaxs[0] = reader.ReadSingle();
                    temp.bbmaxs[1] = reader.ReadSingle();
                    temp.bbmaxs[2] = reader.ReadSingle();
                    temp.xyradius  = reader.ReadSingle();
                    temp.radius    = reader.ReadSingle();

                    if (i == 0)
                    {
                        sm.size = temp.radius;
                    }
                }

                //read comments
                stream.Seek(myHeader.ofs_comment, SeekOrigin.Begin);
                int charRead = 0;
                while (charRead < myHeader.num_comment)
                {
                    char   c = reader.ReadChar(); charRead++;
                    string s = "";
                    while (c != '\0')
                    {
                        s += c;
                        c  = reader.ReadChar(); charRead++;
                    }

                    myComments.Add(s);
                }

                //read extensions
                //TODO

                //setup the bone data
                Matrix4[] baseframe        = new Matrix4[myHeader.num_joints];
                Matrix4[] inversebaseframe = new Matrix4[myHeader.num_joints];
                for (int i = 0; i < (int)myHeader.num_joints; i++)
                {
                    iqmjoint joint = myJoints[i];
                    Matrix4  r, t, s;
                    r                   = Matrix4.CreateFromQuaternion(joint.rotate);
                    t                   = Matrix4.CreateTranslation(joint.translate);
                    s                   = Matrix4.CreateScale(joint.scale);
                    baseframe[i]        = s * r * t;
                    inversebaseframe[i] = baseframe[i].Inverted();
                    if (joint.parent >= 0)
                    {
                        baseframe[i]        = baseframe[i] * baseframe[joint.parent];
                        inversebaseframe[i] = inversebaseframe[joint.parent] * inversebaseframe[i];
                    }

                    Bone b = new Bone();
                    b.myName            = myJoints[i].name;
                    b.myParent          = myJoints[i].parent;
                    b.myWorldBindMatrix = baseframe[i];
                    sm.skeleton.myBones.Add(b);
                }

                Matrix4[] absMatrix = new Matrix4[myHeader.num_frames * myHeader.num_poses];
                int       count     = 0;
                for (int i = 0; i < myHeader.num_frames; i++)
                {
                    for (int j = 0; j < myHeader.num_poses; j++)
                    {
                        iqmpose    p         = myPoses[j];
                        Quaternion rotate    = new Quaternion();
                        Vector3    translate = new Vector3();
                        Vector3    scale     = new Vector3();
                        translate.X = p.channeloffset[0]; if ((p.channelmask & 0x01) != 0)
                        {
                            translate.X += myFrameData[count++] * p.channelscale[0];
                        }
                        translate.Y = p.channeloffset[1]; if ((p.channelmask & 0x02) != 0)
                        {
                            translate.Y += myFrameData[count++] * p.channelscale[1];
                        }
                        translate.Z = p.channeloffset[2]; if ((p.channelmask & 0x04) != 0)
                        {
                            translate.Z += myFrameData[count++] * p.channelscale[2];
                        }
                        rotate.X = p.channeloffset[3]; if ((p.channelmask & 0x08) != 0)
                        {
                            rotate.X += myFrameData[count++] * p.channelscale[3];
                        }
                        rotate.Y = p.channeloffset[4]; if ((p.channelmask & 0x10) != 0)
                        {
                            rotate.Y += myFrameData[count++] * p.channelscale[4];
                        }
                        rotate.Z = p.channeloffset[5]; if ((p.channelmask & 0x20) != 0)
                        {
                            rotate.Z += myFrameData[count++] * p.channelscale[5];
                        }
                        rotate.W = p.channeloffset[6]; if ((p.channelmask & 0x40) != 0)
                        {
                            rotate.W += myFrameData[count++] * p.channelscale[6];
                        }
                        scale.X = p.channeloffset[7]; if ((p.channelmask & 0x80) != 0)
                        {
                            scale.X += myFrameData[count++] * p.channelscale[7];
                        }
                        scale.Y = p.channeloffset[8]; if ((p.channelmask & 0x100) != 0)
                        {
                            scale.Y += myFrameData[count++] * p.channelscale[8];
                        }
                        scale.Z = p.channeloffset[9]; if ((p.channelmask & 0x200) != 0)
                        {
                            scale.Z += myFrameData[count++] * p.channelscale[9];
                        }
                        // Concatenate each pose with the inverse base pose to avoid doing this at animation time.
                        // If the joint has a parent, then it needs to be pre-concatenated with its parent's base pose.
                        // Thus it all negates at animation time like so:
                        //   (parentPose * parentInverseBasePose) * (parentBasePose * childPose * childInverseBasePose) =>
                        //   parentPose * (parentInverseBasePose * parentBasePose) * childPose * childInverseBasePose =>
                        //   parentPose * childPose * childInverseBasePose
                        rotate.Normalize();
                        Matrix4 r, t, s;
                        r = Matrix4.CreateFromQuaternion(rotate);
                        t = Matrix4.CreateTranslation(translate);
                        s = Matrix4.CreateScale(scale);
                        Matrix4 pose = s * r * t;
                        if (p.parent >= 0)
                        {
                            Matrix4 parent     = baseframe[p.parent];
                            Matrix4 inv        = inversebaseframe[j];
                            Matrix4 parentPose = absMatrix[i * myHeader.num_poses + p.parent];
                            absMatrix[i * myHeader.num_poses + j] = inv * pose * parent * parentPose;
                        }
                        else
                        {
                            Matrix4 inv = inversebaseframe[j];
                            absMatrix[i * myHeader.num_poses + j] = inv * pose;
                        }
                    }
                }

                Vector4[] boneData = new Vector4[myHeader.num_frames * myHeader.num_poses * 4];
                int       next     = 0;
                for (int i = 0; i < myHeader.num_frames * myHeader.num_poses; i++)
                {
                    boneData[next++] = absMatrix[i].Row0;
                    boneData[next++] = absMatrix[i].Row1;
                    boneData[next++] = absMatrix[i].Row2;
                    boneData[next++] = absMatrix[i].Row3;
                }

                //setup the buffers
                sm.myBindings = V3N3T2B4W4.bindings();
                VertexBufferObject vbo = new VertexBufferObject(BufferUsageHint.StaticDraw);
                vbo.setData(vertexData);
                sm.myVbos.Add(vbo);

                List <ushort> indexes    = new List <ushort>();
                int           indexCount = 0;
                for (int m = 0; m < sm.myMeshes.Count; m++)
                {
                    Mesh mesh = sm.myMeshes[m];
                    mesh.primativeType = PrimitiveType.Triangles;
                    mesh.indexBase     = indexCount;

                    for (int t = 0; t < meshData[m].num_triangles; t++)
                    {
                        //swap the order the indicies since we want counter clockwise triangles instead of clockwise
                        indexes.Add(triangleIndexes[meshData[m].first_triangle * 3 + (t * 3) + 0]);
                        indexes.Add(triangleIndexes[meshData[m].first_triangle * 3 + (t * 3) + 2]);
                        indexes.Add(triangleIndexes[meshData[m].first_triangle * 3 + (t * 3) + 1]);
                        indexCount += 3;
                    }

                    mesh.indexCount = indexCount - mesh.indexBase;
                }

                sm.myIbo.setData(indexes);

                //upload the frame data
                sm.myFrames.setData(boneData);

                return(sm);
            }
            catch (Exception ex)
            {
                throw new Exception("Error while loading IQM model from definition file ( " + filename + " ).", ex);
            }
            finally
            {
                if (reader != null)
                {
                    reader.Close();
                }
                if (stream != null)
                {
                    stream.Close();
                    stream.Dispose();
                }
            }
        }
Пример #48
0
 //methods using the internal BinaryReader:
 public char getChar()
 {
     return(reader.ReadChar());
 }