public UIntPtr ReadUInt32Ptr(IntPtr address)
 {
     return(new UIntPtr(BitConverter.ToUInt32(ReadBytes(address, 4), 0)));
 }
Beispiel #2
0
        public async Task <uint> GetCurrentScreen(CancellationToken token)
        {
            var data = await Connection.ReadBytesAsync(CurrentScreenOffset, 4, token).ConfigureAwait(false);

            return(BitConverter.ToUInt32(data, 0));
        }
Beispiel #3
0
        public static PingReplyExt Send(IPAddress srcAddress, IPAddress destAddress, int timeout = 5000, byte[] buffer = null, PingOptions po = null)
        {
            if (destAddress == null || destAddress.AddressFamily != System.Net.Sockets.AddressFamily.InterNetwork || destAddress.Equals(IPAddress.Any))
            {
                throw new ArgumentException();
            }

            //Defining pinvoke args
            var source = srcAddress == null ? 0 : BitConverter.ToUInt32(srcAddress.GetAddressBytes(), 0);
            //Console.WriteLine($"source = {source}");
            var destination = BitConverter.ToUInt32(destAddress.GetAddressBytes(), 0);
            var sendbuffer  = buffer ?? new byte[] { };
            var options     = new Interop.Option {
                Ttl   = (po == null ? (byte)255 : (byte)po.Ttl),
                Flags = (po == null ? (byte)0 : po.DontFragment ? (byte)0x02 : (byte)0) //0x02
            };
            var fullReplyBufferSize = Interop.ReplyMarshalLength + sendbuffer.Length;   //Size of Reply struct and the transmitted buffer length.



            var allocSpace = Marshal.AllocHGlobal(fullReplyBufferSize); // unmanaged allocation of reply size. TODO Maybe should be allocated on stack

            try {
                DateTime start      = DateTime.Now;
                var      nativeCode = Interop.IcmpSendEcho2Ex(
                    Interop.IcmpHandle,       //_In_      HANDLE IcmpHandle,
                    default(IntPtr),          //_In_opt_  HANDLE Event,
                    default(IntPtr),          //_In_opt_  PIO_APC_ROUTINE ApcRoutine,
                    default(IntPtr),          //_In_opt_  PVOID ApcContext
                    source,                   //_In_      IPAddr SourceAddress,
                    destination,              //_In_      IPAddr DestinationAddress,
                    sendbuffer,               //_In_      LPVOID RequestData,
                    (short)sendbuffer.Length, //_In_      WORD RequestSize,
                    ref options,              //_In_opt_  PIP_OPTION_INFORMATION RequestOptions,
                    allocSpace,               //_Out_     LPVOID ReplyBuffer,
                    fullReplyBufferSize,      //_In_      DWORD ReplySize,
                    timeout                   //_In_      DWORD Timeout
                    );
                TimeSpan duration = DateTime.Now - start;
                var      reply    = (Interop.Reply)Marshal.PtrToStructure(allocSpace, typeof(Interop.Reply)); // Parse the beginning of reply memory to reply struct

                byte[] replyBuffer = null;
                if (sendbuffer.Length != 0)
                {
                    replyBuffer = new byte[sendbuffer.Length];
                    Marshal.Copy(allocSpace + Interop.ReplyMarshalLength, replyBuffer, 0, sendbuffer.Length); //copy the rest of the reply memory to managed byte[]
                }

                if (nativeCode == 0) //Means that native method is faulted.
                {
                    return(new PingReplyExt(nativeCode, reply.Status, new IPAddress(reply.Address), duration));
                }
                else
                {
                    return(new PingReplyExt(nativeCode, reply.Status, new IPAddress(reply.Address), reply.RoundTripTime, replyBuffer));
                }
            }

            finally {
                Marshal.FreeHGlobal(allocSpace); //free allocated space
            }
        }
Beispiel #4
0
 private static string HashUid(string id)
 {
     return(string.Format("411.12.8453.12.83109.70.5.{0}", BitConverter.ToUInt32(BitConverter.GetBytes(id.GetHashCode()), 0)));
 }
Beispiel #5
0
        public async Task <bool> CheckIfSearchingForSurprisePartner(CancellationToken token)
        {
            var data = await Connection.ReadBytesAsync(SurpriseTradeSearchOffset, 8, token).ConfigureAwait(false);

            return(BitConverter.ToUInt32(data, 0) == SurpriseTradeSearch_Searching);
        }
Beispiel #6
0
 protected void UpdateFloat(float value, int primary, int secondary)
 {
     DoUpdate(BitConverter.ToUInt32(BitConverter.GetBytes(value), 0), primary, secondary, true);
 }
Beispiel #7
0
        private void SaveStats(string id, byte[] data)
        {
            byte house;

            switch (id)
            {
            case "TIME":
                var timeSpan = TimeSpan.FromSeconds(BitConverter.ToUInt32(Reverse(data), 0));
                GameDuration = string.Format("{0:D2}:{1:D2}:{2:D2}", timeSpan.Hours, timeSpan.Minutes, timeSpan.Seconds);
                break;

            case "SCR0":
            case "SCR1":
            case "SCR2":
            case "SCR3":
            case "SCR4":
            case "SCR5":
            case "SCR6":
            case "SCR7":
                string[] score = Encoding.Default.GetString(data).Split('/');
                house = Convert.ToByte(id[id.Length - 1].ToString());
                FinishingPlaces[house]    = Convert.ToInt32(score[0]) + 1;
                BuildingsOwned[house]     = Convert.ToInt32(score[1]);
                BuildingsLost[house]      = Convert.ToInt32(score[2]);
                BuildingsDestroyed[house] = Convert.ToInt32(score[3]);
                UnitsOwned[house]         = Convert.ToInt32(score[4]);
                UnitsLost[house]          = Convert.ToInt32(score[5]);
                UnitsKilled[house]        = Convert.ToInt32(score[6]);
                SpiceHarvested[house]     = Convert.ToInt32(score[7]);
                break;

            case "GEND":
                EndStatus = Encoding.Default.GetString(data);
                break;

            case "GMAP":
                MapName = Encoding.Default.GetString(data);
                break;

            case "GSET":
                string[] gameSettings = Encoding.Default.GetString(data).Split(' ');
                Worms           = Convert.ToInt32(gameSettings[1]);
                Crates          = gameSettings[3] == "1";
                StartingCredits = Convert.ToUInt32(gameSettings[5]);
                TechLevel       = Convert.ToInt32(gameSettings[7]);
                break;

            case "PL_0":
            case "PL_1":
            case "PL_2":
            case "PL_3":
            case "PL_4":
            case "PL_5":
            case "PL_6":
            case "PL_7":
                PlayerCount++;
                string[] playerSettings = Encoding.Default.GetString(data).Split('/');
                house            = Convert.ToByte(id[id.Length - 1].ToString());
                Names[house]     = playerSettings[0];
                Sides[house]     = playerSettings[1];
                Colors[house]    = NumberToColor(playerSettings[2]);
                Handicaps[house] = Convert.ToInt32(playerSettings[3]) + 1;
                break;

            case "SDFX":
                SuddenDisconnect = data[0] == 1;
                break;

            case "TRNY":
                TournamentGame = data[0] == 1;
                break;

            case "GMID":
                GameId = BitConverter.ToUInt32(Reverse(data), 0);
                break;

            case "TICK":
                GameTicks = BitConverter.ToUInt32(Reverse(data), 0);
                break;

            case "UNIT":
                UnitCount = BitConverter.ToUInt32(Reverse(data), 0);
                break;

            case "UNB0":
            case "UNB1":
            case "UNB2":
            case "UNB3":
            case "UNB4":
            case "UNB5":
            case "UNB6":
            case "UNB7":
                house = Convert.ToByte(id[id.Length - 1].ToString());
                SaveUnitsOwned(house, data);
                break;

            case "BLB0":
            case "BLB1":
            case "BLB2":
            case "BLB3":
            case "BLB4":
            case "BLB5":
            case "BLB6":
            case "BLB7":
                house = Convert.ToByte(id[id.Length - 1].ToString());
                SaveBuildingsOwned(house, data);
                break;

            case "CRD0":
            case "CRD1":
            case "CRD2":
            case "CRD3":
            case "CRD4":
            case "CRD5":
            case "CRD6":
            case "CRD7":
                house          = Convert.ToByte(id[id.Length - 1].ToString());
                Credits[house] = BitConverter.ToInt32(Reverse(data), 0);
                break;
            }
        }
        private void ExtractData()
        {
            int position  = 0;
            int finalSize = 0;

            byte[] queueToBreak = null;
            List <ArraySegment <byte> > segmentList = new List <ArraySegment <byte> >();

            lock (queuelock)
            {
                if (m_buffers.Count > 0)
                {
                    while (m_buffers.Count > 0)
                    {
                        byte[] localqueueChunk = m_buffers.Dequeue();
                        chunkList.AddRange(localqueueChunk);
                        position += localqueueChunk.Length;
                    }

                    byte[] queueChunk = chunkList.ToArray();
                    chunkList.Clear();
                    queueToBreak = new byte[queueChunk.Length];
                    segmentList  = new List <ArraySegment <byte> >();
                    for (int i = 0; i < queueChunk.Length;)
                    {
                        int size = 0;
                        if (queueChunk.Length - 4 >= i + 4)
                        {
                            size = BitConverter.ToInt32(queueChunk, i);
                        }
                        if (size > 0 && queueChunk.Length >= i + size && BitConverter.ToUInt32(queueChunk, (i + size) - 4) == 0xCCCCCCCC)
                        {
                            segmentList.Add(new ArraySegment <byte>(queueChunk, i + 4, size - 8));
                            finalSize += (size - 8);
                            i         += size;
                        }
                        else
                        {
                            byte[] remainder = new byte[queueChunk.Length - i];
                            Array.Copy(queueChunk, i, remainder, 0, queueChunk.Length - i);
                            m_buffers.Enqueue(remainder);
                            break;
                        }
                    }
                }
            }
            lock (chunklock)
            {
                if (finalSize > 0)
                {
                    var listOfSizes = new List <int>();
                    Array.Resize(ref queueToBreak, finalSize);
                    foreach (var item in segmentList)
                    {
                        for (int i = 0; i < item.Count;)
                        {
                            var startOffset = i + item.Offset;
                            int size        = BitConverter.ToInt32(item.Array, startOffset);
                            if (size > 0 && size < 4096)
                            {
                                listOfSizes.Add(size);
                                var segment = new ArraySegment <byte>(item.Array, startOffset, size);
                                m_items.Enqueue(segment);
                                i += size;
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                    HasData(this);
                }
            }
        }
Beispiel #9
0
        /// <summary>
        /// Tries to connect to login server, keeps trying every 10 seconds
        /// till there is a success. Blocking.
        /// </summary>
        public void ConnectToLogin(bool firstTime)
        {
            if (this.LoginServer != null && this.LoginServer.State == ClientState.LoggedIn)
            {
                throw new Exception("Channel already connected to login server.");
            }

            Log.WriteLine();

            if (firstTime)
            {
                Log.Info("Trying to connect to login server at {0}:{1}...", ChannelServer.Instance.Conf.Channel.LoginHost, ChannelServer.Instance.Conf.Channel.LoginPort);
            }
            else
            {
                Log.Info("Trying to re-connect to login server in {0} seconds.", LoginTryTime / 1000);
                Thread.Sleep(LoginTryTime);
            }

            var success = false;

            while (!success)
            {
                try
                {
                    if (this.LoginServer != null && this.LoginServer.State != ClientState.Dead)
                    {
                        this.LoginServer.Kill();
                    }

                    this.LoginServer        = new InternalClient();
                    this.LoginServer.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    this.LoginServer.Socket.Connect(ChannelServer.Instance.Conf.Channel.LoginHost, ChannelServer.Instance.Conf.Channel.LoginPort);

                    var buffer = new byte[255];

                    // Recv Seed, send back empty packet to get done with the challenge.
                    this.LoginServer.Socket.Receive(buffer);
                    this.LoginServer.Crypto = new MabiCrypto(BitConverter.ToUInt32(buffer, 0), false);
                    this.LoginServer.Send(Packet.Empty());

                    // Challenge end
                    this.LoginServer.Socket.Receive(buffer);

                    // Inject login server into normal data receiving.
                    this.Server.AddReceivingClient(this.LoginServer);

                    // Identify
                    this.LoginServer.State = ClientState.LoggingIn;

                    success = true;

                    Send.Internal_ServerIdentify();
                }
                catch (Exception ex)
                {
                    Log.Error("Unable to connect to login server. ({0})", ex.Message);
                    Log.Info("Trying again in {0} seconds.", LoginTryTime / 1000);
                    Thread.Sleep(LoginTryTime);
                }
            }

            Log.Info("Connection to login server at '{0}' established.", this.LoginServer.Address);
            Log.WriteLine();
        }
Beispiel #10
0
 /// <summary>
 /// Reads a 32-bit unsigned integer.
 /// </summary>
 /// <param name="value">The value that was read.</param>
 /// <returns></returns>
 public EasyReader ReadUInt32(out uint value)
 {
     value = BitConverter.ToUInt32(ReadAndFormat(4), 0);
     return(this);
 }
Beispiel #11
0
        public static void Forge(
            [Required(Description = "original signed assembly")]
            string originalPath,
            [Required(Description = "input modified assembly")]
            string inputPath,
            [Required(Description = "output forged assembly")]
            string outputPath)
        {
            Stream original = File.OpenRead(originalPath);

            bool   isEncrypted = original.ReadValueBoolean();
            UInt32 typeId      = original.ReadValueU32();

            if (isEncrypted == false || typeId != 0x2BC4F79F)
            {
                Console.WriteLine("Not an encrypted assembly that I know how to handle.");
                original.Close();
                return;
            }

            byte[] theirSum = new byte[64];
            original.Read(theirSum, 0, theirSum.Length);

            ushort blocks = original.ReadValueU16();

            byte[] table = new byte[blocks * 8];
            original.Read(table, 0, table.Length);
            original.Close();

            // Calculate initial seed
            UInt32 seed = 0;

            for (int i = 0; i < blocks; i++)
            {
                seed += BitConverter.ToUInt32(table, i * 8);
            }
            seed = (UInt32)(table.Length - 1) & seed;

            Stream input = File.OpenRead(inputPath);

            if (input.Length != blocks * 512)
            {
                Console.WriteLine("Size mismatch, original assembly and modified assembly must have the same size! ({0} vs {1})", input.Length, blocks * 512);
                input.Close();
                original.Close();
                return;
            }

            Stream output = File.Open(outputPath, FileMode.Create, FileAccess.Write);

            output.WriteValueBoolean(true);
            output.WriteValueU32(0x2BC4F79F);
            output.Write(theirSum, 0, theirSum.Length);
            output.WriteValueU16(blocks);
            output.Write(table, 0, table.Length);

            // Encrypt data
            for (int i = 0; i < blocks; i++)
            {
                byte[] data = new byte[512];
                input.Read(data, 0, data.Length);

                if ((table[(i * 8)] & 1) == 0) // non-empty block
                {
                    for (int j = 0; j < 512; j++)
                    {
                        data[j] ^= table[seed];
                        seed     = (UInt32)((seed + data[j]) % table.Length);
                    }

                    output.Write(data, 0, data.Length);
                }
                else // validate this is an empty block
                {
                    for (int j = 0; j < data.Length; j++)
                    {
                        if (data[j] != 0)
                        {
                            Console.WriteLine("Block {0} should have been empty, but wasn't!", i);
                            input.Close();
                            output.Close();
                            return;
                        }
                    }
                }
            }

            output.Close();
            original.Close();

            Console.WriteLine("Done.");
        }
Beispiel #12
0
 /// <summary>
 /// Reads a 32-bit unsigned integer.
 /// </summary>
 /// <returns></returns>
 public uint ReadUInt32()
 {
     return(BitConverter.ToUInt32(ReadAndFormat(4), 0));
 }
Beispiel #13
0
 private void method_0(Stream TMD_Stream, SystemType SystemType) //Information located: https://3dbrew.org/wiki/Title_metadata#Signature_Type
 {
     TMD_Stream.Seek(0L, SeekOrigin.Begin);
     byte[] buffer1 = new byte[8];
     TMD_Stream.Read(buffer1, 0, 4);
     this.TMD_Signature__Type_as_Int = GClass27.ToUIntNetworkBytes(BitConverter.ToUInt32(buffer1, 0));
     TMD_Stream.Read(this.TMD_Signature, 0, this.TMD_Signature.Length);
     TMD_Stream.Read(this.TMD_Signature_Padding, 0, this.TMD_Signature_Padding.Length);
     TMD_Stream.Read(this.SignatureIssuer, 0, this.SignatureIssuer.Length);
     TMD_Stream.Read(buffer1, 0, 4);
     this.Version            = buffer1[0];
     this.ca_crl_version     = buffer1[1];
     this.signer_crl_version = buffer1[2];
     this.Reserved           = buffer1[3];
     TMD_Stream.Read(buffer1, 0, 8);                                      //Skip System Version
     TMD_Stream.Read(buffer1, 0, 8);                                      //Read Title ID
     this.TitleId = GClass27.ToULongNetworkBytes(BitConverter.ToUInt64(buffer1, 0));
     TMD_Stream.Read(buffer1, 0, 4);                                      //Read Title Type (e.g. DSIWare, ESHOP, etc I think)
     this.TitleType = GClass27.ToUIntNetworkBytes(BitConverter.ToUInt32(buffer1, 0));
     TMD_Stream.Read(buffer1, 0, 2);                                      //Read Group ID
     this.GroupID = GClass27.ToUShortNetworkBytes(BitConverter.ToUInt16(buffer1, 0));
     TMD_Stream.Read(buffer1, 0, 2);                                      //Read half of Save Data Size (Bytes) (Also SRL Public Save Data Size)?
     this.Save_Data_Size_pt1 = GClass27.ToUShortNetworkBytes(BitConverter.ToUInt16(buffer1, 0));
     TMD_Stream.Read(buffer1, 0, 2);                                      //Read second half of Save Data Size (Bytes) (Also SRL Public Save Data Size)?
     this.Save_Data_Size_pt2 = GClass27.ToUShortNetworkBytes(BitConverter.ToUInt16(buffer1, 0));
     TMD_Stream.Read(this.SkippedSLRData, 0, this.SkippedSLRData.Length); //Skips SLR Private Save, Reserved, SLR Flag, and Reserved
     TMD_Stream.Read(buffer1, 0, 4);                                      //Reads Access Rights
     this.AccessRights = GClass27.ToUIntNetworkBytes(BitConverter.ToUInt32(buffer1, 0));
     TMD_Stream.Read(buffer1, 0, 8);                                      //Read Title Version, Content Count, Boot Content, and Padding
     this.TitleVersion  = GClass27.ToUShortNetworkBytes(BitConverter.ToUInt16(buffer1, 0));
     this.NumOfContents = GClass27.ToUShortNetworkBytes(BitConverter.ToUInt16(buffer1, 2));
     this.BootContent   = GClass27.ToUShortNetworkBytes(BitConverter.ToUInt16(buffer1, 4));
     this.Padding       = GClass27.ToUShortNetworkBytes(BitConverter.ToUInt16(buffer1, 6));
     if (SystemType != SystemType.SystemWii)
     {
         TMD_Stream.Position = 2820L; //Skips to Hex 0xB02
     }
     this.list_0 = new List <GClass101>();
     for (int index = 0; index < (int)this.NumOfContents; ++index)
     {
         GClass101 gclass101;
         if (SystemType != SystemType.SystemWiiU && SystemType != SystemType.SystemWii)
         {
             if (SystemType != SystemType.System3DS)
             {
                 throw new NotImplementedException();
             }
             A_3DS_CND_File_Hash A_3DS_CDN_File_Hash = new A_3DS_CND_File_Hash();
             A_3DS_CDN_File_Hash.Hash = new byte[32];
             gclass101 = (GClass101)A_3DS_CDN_File_Hash;
         }
         else
         {
             A_WiiU_CDN_File_Hash A_WiiU_CDN_File_Hash = new A_WiiU_CDN_File_Hash();
             A_WiiU_CDN_File_Hash.Hash = new byte[20];
             gclass101 = (GClass101)A_WiiU_CDN_File_Hash;
         }
         TMD_Stream.Read(buffer1, 0, 8);
         gclass101.ContentId   = GClass27.ToUIntNetworkBytes(BitConverter.ToUInt32(buffer1, 0));
         gclass101.Index       = GClass27.ToUShortNetworkBytes(BitConverter.ToUInt16(buffer1, 4));
         gclass101.ContentType = (GEnum6)GClass27.ToUShortNetworkBytes(BitConverter.ToUInt16(buffer1, 6));
         TMD_Stream.Read(buffer1, 0, 8);
         gclass101.ContentSize = new DataSize(GClass27.ToULongNetworkBytes(BitConverter.ToUInt64(buffer1, 0)));
         TMD_Stream.Read(gclass101.Hash, 0, gclass101.Hash.Length);
         this.list_0.Add(gclass101);
         if (SystemType == SystemType.SystemWiiU)
         {
             byte[] buffer2 = new byte[12];
             TMD_Stream.Read(buffer2, 0, 12);
         }
     }
     TMD_Stream.Read(this.Certificate1, 0, this.Certificate1.Length);
     TMD_Stream.Read(this.Certificate2, 0, this.Certificate2.Length);
 }
Beispiel #14
0
 ///<summary>
 /// Returns a random number between 0.0 and 1.0.
 ///</summary>
 public double NextDouble()
 {
     byte[] b = new byte[4];
     r.GetBytes(b);
     return((double)BitConverter.ToUInt32(b, 0) / UInt32.MaxValue);
 }
            protected override Task <ResultStatus> DoCommandOverride(ICommandContext commandContext)
            {
                var assetManager = new AssetManager();

                AssetParameters.ColliderShapes = AssetParameters.ColliderShapes.Where(x => x != null &&
                                                                                      (x.GetType() != typeof(ConvexHullColliderShapeDesc) || ((ConvexHullColliderShapeDesc)x).Model != null)).ToList();

                //pre process special types
                foreach (var convexHullDesc in
                         (from shape in AssetParameters.ColliderShapes let type = shape.GetType() where type == typeof(ConvexHullColliderShapeDesc) select shape)
                         .Cast <ConvexHullColliderShapeDesc>())
                {
                    //decompose and fill vertex data

                    var loadSettings = new AssetManagerLoaderSettings
                    {
                        ContentFilter = AssetManagerLoaderSettings.NewContentFilterByType(typeof(Mesh))
                    };

                    var modelAsset = assetManager.Load <Model>(AttachedReferenceManager.GetUrl(convexHullDesc.Model), loadSettings);
                    if (modelAsset == null)
                    {
                        continue;
                    }

                    convexHullDesc.ConvexHulls        = new List <List <List <Vector3> > >();
                    convexHullDesc.ConvexHullsIndices = new List <List <List <uint> > >();

                    commandContext.Logger.Info("Processing convex hull generation, this might take a while!");

                    var nodeTransforms = new List <Matrix>();

                    //pre-compute all node transforms, assuming nodes are ordered... see ModelViewHierarchyUpdater
                    var nodesLength = modelAsset.Skeleton.Nodes.Length;
                    for (var i = 0; i < nodesLength; i++)
                    {
                        Matrix localMatrix;
                        TransformComponent.CreateMatrixTRS(
                            ref modelAsset.Skeleton.Nodes[i].Transform.Position,
                            ref modelAsset.Skeleton.Nodes[i].Transform.Rotation,
                            ref modelAsset.Skeleton.Nodes[i].Transform.Scale, out localMatrix);

                        Matrix worldMatrix;
                        if (modelAsset.Skeleton.Nodes[i].ParentIndex != -1)
                        {
                            var nodeTransform = nodeTransforms[modelAsset.Skeleton.Nodes[i].ParentIndex];
                            Matrix.Multiply(ref localMatrix, ref nodeTransform, out worldMatrix);
                        }
                        else
                        {
                            worldMatrix = localMatrix;
                        }

                        nodeTransforms.Add(worldMatrix);
                    }

                    for (var i = 0; i < nodesLength; i++)
                    {
                        var i1 = i;
                        if (modelAsset.Meshes.All(x => x.NodeIndex != i1))
                        {
                            continue;                                                // no geometry in the node
                        }
                        var combinedVerts   = new List <float>();
                        var combinedIndices = new List <uint>();

                        var hullsList = new List <List <Vector3> >();
                        convexHullDesc.ConvexHulls.Add(hullsList);

                        var indicesList = new List <List <uint> >();
                        convexHullDesc.ConvexHullsIndices.Add(indicesList);

                        foreach (var meshData in modelAsset.Meshes.Where(x => x.NodeIndex == i1))
                        {
                            var indexOffset = (uint)combinedVerts.Count / 3;

                            var stride          = meshData.Draw.VertexBuffers[0].Declaration.VertexStride;
                            var vertexDataAsset = assetManager.Load <Graphics.Buffer>(AttachedReferenceManager.GetUrl(meshData.Draw.VertexBuffers[0].Buffer));
                            var vertexData      = vertexDataAsset.GetSerializationData().Content;
                            var vertexIndex     = meshData.Draw.VertexBuffers[0].Offset;
                            for (var v = 0; v < meshData.Draw.VertexBuffers[0].Count; v++)
                            {
                                var posMatrix = Matrix.Translation(new Vector3(BitConverter.ToSingle(vertexData, vertexIndex + 0), BitConverter.ToSingle(vertexData, vertexIndex + 4), BitConverter.ToSingle(vertexData, vertexIndex + 8)));

                                Matrix rotatedMatrix;
                                var    nodeTransform = nodeTransforms[i];
                                Matrix.Multiply(ref posMatrix, ref nodeTransform, out rotatedMatrix);

                                combinedVerts.Add(rotatedMatrix.TranslationVector.X);
                                combinedVerts.Add(rotatedMatrix.TranslationVector.Y);
                                combinedVerts.Add(rotatedMatrix.TranslationVector.Z);

                                vertexIndex += stride;
                            }

                            var indexDataAsset = assetManager.Load <Graphics.Buffer>(AttachedReferenceManager.GetUrl(meshData.Draw.IndexBuffer.Buffer));
                            var indexData      = indexDataAsset.GetSerializationData().Content;
                            var indexIndex     = meshData.Draw.IndexBuffer.Offset;
                            for (var v = 0; v < meshData.Draw.IndexBuffer.Count; v++)
                            {
                                if (meshData.Draw.IndexBuffer.Is32Bit)
                                {
                                    combinedIndices.Add(BitConverter.ToUInt32(indexData, indexIndex) + indexOffset);
                                    indexIndex += 4;
                                }
                                else
                                {
                                    combinedIndices.Add(BitConverter.ToUInt16(indexData, indexIndex) + indexOffset);
                                    indexIndex += 2;
                                }
                            }
                        }

                        var decompositionDesc = new ConvexHullMesh.DecompositionDesc
                        {
                            VertexCount   = (uint)combinedVerts.Count / 3,
                            IndicesCount  = (uint)combinedIndices.Count,
                            Vertexes      = combinedVerts.ToArray(),
                            Indices       = combinedIndices.ToArray(),
                            Depth         = convexHullDesc.Depth,
                            PosSampling   = convexHullDesc.PosSampling,
                            PosRefine     = convexHullDesc.PosRefine,
                            AngleSampling = convexHullDesc.AngleSampling,
                            AngleRefine   = convexHullDesc.AngleRefine,
                            Alpha         = convexHullDesc.Alpha,
                            Threshold     = convexHullDesc.Threshold,
                            SimpleHull    = convexHullDesc.SimpleWrap
                        };

                        lock (this)
                        {
                            convexHullMesh = new ConvexHullMesh();
                        }

                        convexHullMesh.Generate(decompositionDesc);

                        var count = convexHullMesh.Count;

                        commandContext.Logger.Info("Node generated " + count + " convex hulls");

                        var vertexCountHull = 0;

                        for (uint h = 0; h < count; h++)
                        {
                            float[] points;
                            convexHullMesh.CopyPoints(h, out points);

                            var pointList = new List <Vector3>();

                            for (var v = 0; v < points.Length; v += 3)
                            {
                                var vert = new Vector3(points[v + 0], points[v + 1], points[v + 2]);
                                pointList.Add(vert);

                                vertexCountHull++;
                            }

                            hullsList.Add(pointList);

                            uint[] indices;
                            convexHullMesh.CopyIndices(h, out indices);

                            for (var t = 0; t < indices.Length; t += 3)
                            {
                                Utilities.Swap(ref indices[t], ref indices[t + 2]);
                            }

                            var indexList = new List <uint>(indices);

                            indicesList.Add(indexList);
                        }

                        lock (this)
                        {
                            convexHullMesh.Dispose();
                            convexHullMesh = null;
                        }

                        commandContext.Logger.Info("For a total of " + vertexCountHull + " vertexes");
                    }
                }

                var runtimeShape = new PhysicsColliderShape {
                    Descriptions = AssetParameters.ColliderShapes
                };

                assetManager.Save(Url, runtimeShape);

                return(Task.FromResult(ResultStatus.Successful));
            }
Beispiel #16
0
        internal Midpoint[] CacheMidpointsAndVerifyHash(int depth, bool skipIndexVerify)
        {
            var buffer = new byte[4096];

            if (depth < 0 || depth > 30)
            {
                throw new ArgumentOutOfRangeException("depth");
            }
            var count = Count;

            if (count == 0 || depth == 0)
            {
                return(null);
            }

            if (skipIndexVerify)
            {
                Log.Debug("Disabling Verification of PTable");
            }
#if  MONO
            var workItem = GetWorkItem();
            var stream   = workItem.Stream;
            try {
#else
            using (var stream = UnbufferedFileStream.Create(_filename, FileMode.Open, FileAccess.Read, FileShare.Read, false, 4096, 4096, false, 4096))
            {
#endif
                try {
                    int        midpointsCount;
                    Midpoint[] midpoints;
                    using (MD5 md5 = MD5.Create())
                    {
                        try
                        {
                            midpointsCount = (int)Math.Max(2L, Math.Min((long)1 << depth, count));
                            midpoints      = new Midpoint[midpointsCount];
                        }
                        catch (OutOfMemoryException exc)
                        {
                            throw new PossibleToHandleOutOfMemoryException("Failed to allocate memory for Midpoint cache.", exc);
                        }

                        if (skipIndexVerify && (_version >= PTableVersions.IndexV4))
                        {
                            if (_midpointsCached == midpointsCount)
                            {
                                //index verification is disabled and cached midpoints with the same depth requested are available
                                //so, we can load them directly from the PTable file
                                Log.Debug("Loading {0} cached midpoints from PTable", _midpointsCached);
                                long startOffset = stream.Length - MD5Size - PTableFooter.GetSize(_version) - _midpointsCacheSize;
                                stream.Seek(startOffset, SeekOrigin.Begin);
                                for (uint k = 0; k < _midpointsCached; k++)
                                {
                                    stream.Read(buffer, 0, _indexEntrySize);
                                    IndexEntryKey key;
                                    long          index;
                                    if (_version == PTableVersions.IndexV4)
                                    {
                                        key   = new IndexEntryKey(BitConverter.ToUInt64(buffer, 8), BitConverter.ToInt64(buffer, 0));
                                        index = BitConverter.ToInt64(buffer, 8 + 8);
                                    }
                                    else
                                    {
                                        throw new InvalidOperationException("Unknown PTable version: " + _version);
                                    }
                                    midpoints[k] = new Midpoint(key, index);

                                    if (k > 0)
                                    {
                                        if (midpoints[k].Key.GreaterThan(midpoints[k - 1].Key))
                                        {
                                            throw new CorruptIndexException(String.Format("Index entry key for midpoint {0} (stream: {1}, version: {2}) < index entry key for midpoint {3} (stream: {4}, version: {5})", k - 1, midpoints[k - 1].Key.Stream, midpoints[k - 1].Key.Version, k, midpoints[k].Key.Stream, midpoints[k].Key.Version));
                                        }
                                        else if (midpoints[k - 1].ItemIndex > midpoints[k].ItemIndex)
                                        {
                                            throw new CorruptIndexException(String.Format("Item index for midpoint {0} ({1}) > Item index for midpoint {2} ({3})", k - 1, midpoints[k - 1].ItemIndex, k, midpoints[k].ItemIndex));
                                        }
                                    }
                                }

                                return(midpoints);
                            }
                            else
                            {
                                Log.Debug("Skipping loading of cached midpoints from PTable due to count mismatch, cached midpoints: {0} / required midpoints: {1}", _midpointsCached, midpointsCount);
                            }
                        }

                        if (!skipIndexVerify)
                        {
                            stream.Seek(0, SeekOrigin.Begin);
                            stream.Read(buffer, 0, PTableHeader.Size);
                            md5.TransformBlock(buffer, 0, PTableHeader.Size, null, 0);
                        }

                        long previousNextIndex = long.MinValue;
                        var  previousKey       = new IndexEntryKey(long.MaxValue, long.MaxValue);
                        for (long k = 0; k < midpointsCount; ++k)
                        {
                            var nextIndex = GetMidpointIndex(k, count, midpointsCount);
                            if (previousNextIndex != nextIndex)
                            {
                                if (!skipIndexVerify)
                                {
                                    ReadUntilWithMd5(PTableHeader.Size + _indexEntrySize * nextIndex, stream, md5);
                                    stream.Read(buffer, 0, _indexKeySize);
                                    md5.TransformBlock(buffer, 0, _indexKeySize, null, 0);
                                }
                                else
                                {
                                    stream.Seek(PTableHeader.Size + _indexEntrySize * nextIndex, SeekOrigin.Begin);
                                    stream.Read(buffer, 0, _indexKeySize);
                                }

                                IndexEntryKey key;
                                if (_version == PTableVersions.IndexV1)
                                {
                                    key = new IndexEntryKey(BitConverter.ToUInt32(buffer, 4), BitConverter.ToInt32(buffer, 0));
                                }
                                else if (_version == PTableVersions.IndexV2)
                                {
                                    key = new IndexEntryKey(BitConverter.ToUInt64(buffer, 4), BitConverter.ToInt32(buffer, 0));
                                }
                                else
                                {
                                    key = new IndexEntryKey(BitConverter.ToUInt64(buffer, 8), BitConverter.ToInt64(buffer, 0));
                                }
                                midpoints[k]      = new Midpoint(key, nextIndex);
                                previousNextIndex = nextIndex;
                                previousKey       = key;
                            }
                            else
                            {
                                midpoints[k] = new Midpoint(previousKey, previousNextIndex);
                            }

                            if (k > 0)
                            {
                                if (midpoints[k].Key.GreaterThan(midpoints[k - 1].Key))
                                {
                                    throw new CorruptIndexException(String.Format("Index entry key for midpoint {0} (stream: {1}, version: {2}) < index entry key for midpoint {3} (stream: {4}, version: {5})", k - 1, midpoints[k - 1].Key.Stream, midpoints[k - 1].Key.Version, k, midpoints[k].Key.Stream, midpoints[k].Key.Version));
                                }
                                else if (midpoints[k - 1].ItemIndex > midpoints[k].ItemIndex)
                                {
                                    throw new CorruptIndexException(String.Format("Item index for midpoint {0} ({1}) > Item index for midpoint {2} ({3})", k - 1, midpoints[k - 1].ItemIndex, k, midpoints[k].ItemIndex));
                                }
                            }
                        }

                        if (!skipIndexVerify)
                        {
                            ReadUntilWithMd5(stream.Length - MD5Size, stream, md5);
                            //verify hash (should be at stream.length - MD5Size)
                            md5.TransformFinalBlock(Empty.ByteArray, 0, 0);
                            var fileHash = new byte[MD5Size];
                            stream.Read(fileHash, 0, MD5Size);
                            ValidateHash(md5.Hash, fileHash);
                        }

                        return(midpoints);
                    }
                }
                catch
                {
                    Dispose();
                    throw;
                }
            }
#if MONO
            finally
            {
                ReturnWorkItem(workItem);
            }
#endif
        }
Beispiel #17
0
        public static void AddBundle(string filepath, Bundle b, SQLiteConnection con, CATFile cat)
        {
            if (b.ebx == null)
            {
                b.ebx = new List <Bundle.ebxtype>();
            }
            if (b.res == null)
            {
                b.res = new List <Bundle.restype>();
            }
            if (b.chunk == null)
            {
                b.chunk = new List <Bundle.chunktype>();
            }
            SQLCommand("INSERT INTO bundles VALUES (NULL,'" + filepath + "','" + b.path + "', " + b.ebx.Count + ", " + b.res.Count + ", " + b.chunk.Count + " )", con);
            SQLiteCommand    command = new SQLiteCommand("SELECT last_insert_rowid()", con);
            SQLiteDataReader reader  = command.ExecuteReader();

            reader.Read();
            long   id          = (long)reader.GetValue(0);
            var    transaction = con.BeginTransaction();
            string basepath    = Path.GetDirectoryName(cat.MyPath) + "\\";

            if (!exceptions.Contains(b.path))
            {
                foreach (Bundle.ebxtype ebx in b.ebx)
                {
                    StringBuilder sb = new StringBuilder();
                    foreach (byte bb in ebx.SHA1)
                    {
                        sb.Append(bb.ToString("X2"));
                    }
                    List <uint> line = cat.FindBySHA1(ebx.SHA1);
                    string      type = "";
                    string      guid = "";
                    if (line.Count == 9)
                    {
                        CASFile          cas   = new CASFile(basepath + "cas_" + line[7].ToString("d2") + ".cas");
                        CASFile.CASEntry entry = cas.ReadEntry(line.ToArray());
                        try
                        {
                            /* Just obtain the Guid and Type from raw EBX */
                            Tools.ExtractEbxGuidAndType(new MemoryStream(entry.data), out type, out guid);
                        }
                        catch (Exception)
                        {
                        }
                    }
                    SQLCommand("INSERT INTO ebx VALUES ('" + ebx.name.Replace("'", "") + "','" + sb.ToString() + "', " + id + ", '" + type + "', '" + guid + "')", con);
                }
            }
            transaction.Commit();
            transaction = con.BeginTransaction();
            foreach (Bundle.restype res in b.res)
            {
                StringBuilder sb = new StringBuilder();
                foreach (byte bb in res.SHA1)
                {
                    sb.Append(bb.ToString("X2"));
                }
                uint restype = BitConverter.ToUInt32(res.rtype, 0);
                SQLCommand("INSERT INTO res VALUES ('" + res.name.Replace("'", "") + "','" + sb.ToString() + "', '" + restype.ToString("X8") + "', " + id + ")", con);
            }
            transaction.Commit();
            transaction = con.BeginTransaction();
            foreach (Bundle.chunktype chunk in b.chunk)
            {
                StringBuilder sb = new StringBuilder();
                foreach (byte bb in chunk.id)
                {
                    sb.Append(bb.ToString("X2"));
                }
                StringBuilder sb2 = new StringBuilder();
                foreach (byte bb2 in chunk.SHA1)
                {
                    sb2.Append(bb2.ToString("X2"));
                }
                SQLCommand("INSERT INTO chunk VALUES ('" + sb.ToString() + "', '" + sb2.ToString() + "', " + id + ")", con);
            }
            transaction.Commit();
        }
Beispiel #18
0
        private object[] ProcessMessageObjects(byte[] message, string name, string format)
        {
            char[] form = format.ToCharArray();

            int offset = 0;

            List <object> answer = new List <object>();

            foreach (char ch in form)
            {
                switch (ch)
                {
                case 'b':
                    answer.Add((sbyte)message[offset]);
                    offset++;
                    break;

                case 'B':
                    answer.Add(message[offset]);
                    offset++;
                    break;

                case 'h':
                    answer.Add(BitConverter.ToInt16(message, offset));
                    offset += 2;
                    break;

                case 'H':
                    answer.Add(BitConverter.ToUInt16(message, offset));
                    offset += 2;
                    break;

                case 'i':
                    answer.Add(BitConverter.ToInt32(message, offset));
                    offset += 4;
                    break;

                case 'I':
                    answer.Add(BitConverter.ToUInt32(message, offset));
                    offset += 4;
                    break;

                case 'q':
                    answer.Add(BitConverter.ToInt64(message, offset));
                    offset += 8;
                    break;

                case 'Q':
                    answer.Add(BitConverter.ToUInt64(message, offset));
                    offset += 8;
                    break;

                case 'f':
                    answer.Add(BitConverter.ToSingle(message, offset));
                    offset += 4;
                    break;

                case 'd':
                    answer.Add(BitConverter.ToDouble(message, offset));
                    offset += 8;
                    break;

                case 'c':
                    answer.Add((BitConverter.ToInt16(message, offset) / 100.0));
                    offset += 2;
                    break;

                case 'C':
                    answer.Add((BitConverter.ToUInt16(message, offset) / 100.0));
                    offset += 2;
                    break;

                case 'e':
                    answer.Add((BitConverter.ToInt32(message, offset) / 100.0));
                    offset += 4;
                    break;

                case 'E':
                    answer.Add((BitConverter.ToUInt32(message, offset) / 100.0));
                    offset += 4;
                    break;

                case 'L':
                    answer.Add(((double)BitConverter.ToInt32(message, offset) / 10000000.0));
                    offset += 4;
                    break;

                case 'n':
                    answer.Add(ASCIIEncoding.ASCII.GetString(message, offset, 4).Trim(new char[] { '\0' }));
                    offset += 4;
                    break;

                case 'N':
                    answer.Add(ASCIIEncoding.ASCII.GetString(message, offset, 16).Trim(new char[] { '\0' }));
                    offset += 16;
                    break;

                case 'M':
                    int modeno = message[offset];
                    answer.Add(modeno);
                    offset++;
                    break;

                case 'Z':
                    answer.Add(ASCIIEncoding.ASCII.GetString(message, offset, 64).Trim(new char[] { '\0' }));
                    offset += 64;
                    break;

                case 'a':
                    answer.Add(new UnionArray(message.Skip(offset).Take(64).ToArray()).Shorts.Take(32));
                    offset += 2 * 32;
                    break;

                default:
                    return(null);
                }
            }
            return(answer.ToArray());
        }
Beispiel #19
0
 public uint Hash(MD5 generator, int index)
 {
     return(BitConverter.ToUInt32(generator.ComputeHash(BitConverter.GetBytes(index)), 0));
 }
Beispiel #20
0
        /*
         * 105    +Format characters in the format string for binary log messages
         * 106    +  b   : int8_t
         * 107    +  B   : uint8_t
         * 108    +  h   : int16_t
         * 109    +  H   : uint16_t
         * 110    +  i   : int32_t
         * 111    +  I   : uint32_t
         * 112    +  f   : float
         *     d   : double
         * 113    +  N   : char[16]
         * 114    +  c   : int16_t * 100
         * 115    +  C   : uint16_t * 100
         * 116    +  e   : int32_t * 100
         * 117    +  E   : uint32_t * 100
         * 118    +  L   : uint32_t latitude/longitude
         * a : short[32]
         * 119    + */


        /// <summary>
        /// Convert to ascii based on the existing format message
        /// </summary>
        /// <param name="message">raw binary message</param>
        /// <param name="name">Message type name</param>
        /// <param name="format">format string containing packet structure</param>
        /// <returns>formated ascii string</returns>
        string ProcessMessage(byte[] message, string name, string format)
        {
            char[] form = format.ToCharArray();

            int offset = 0;

            StringBuilder line = new StringBuilder(name, 1024);

            foreach (char ch in form)
            {
                switch (ch)
                {
                case 'b':
                    line.Append(", " + (sbyte)message[offset]);
                    offset++;
                    break;

                case 'B':
                    line.Append(", " + message[offset]);
                    offset++;
                    break;

                case 'h':
                    line.Append(", " +
                                BitConverter.ToInt16(message, offset)
                                .ToString(System.Globalization.CultureInfo.InvariantCulture));
                    offset += 2;
                    break;

                case 'H':
                    line.Append(", " +
                                BitConverter.ToUInt16(message, offset)
                                .ToString(System.Globalization.CultureInfo.InvariantCulture));
                    offset += 2;
                    break;

                case 'i':
                    line.Append(", " +
                                BitConverter.ToInt32(message, offset)
                                .ToString(System.Globalization.CultureInfo.InvariantCulture));
                    offset += 4;
                    break;

                case 'I':
                    line.Append(", " +
                                BitConverter.ToUInt32(message, offset)
                                .ToString(System.Globalization.CultureInfo.InvariantCulture));
                    offset += 4;
                    break;

                case 'q':
                    line.Append(", " +
                                BitConverter.ToInt64(message, offset)
                                .ToString(System.Globalization.CultureInfo.InvariantCulture));
                    offset += 8;
                    break;

                case 'Q':
                    line.Append(", " +
                                BitConverter.ToUInt64(message, offset)
                                .ToString(System.Globalization.CultureInfo.InvariantCulture));
                    offset += 8;
                    break;

                case 'f':
                    line.Append(", " +
                                BitConverter.ToSingle(message, offset)
                                .ToString(System.Globalization.CultureInfo.InvariantCulture));
                    offset += 4;
                    break;

                case 'd':
                    line.Append(", " +
                                BitConverter.ToDouble(message, offset)
                                .ToString(System.Globalization.CultureInfo.InvariantCulture));
                    offset += 8;
                    break;

                case 'c':
                    line.Append(", " +
                                (BitConverter.ToInt16(message, offset) / 100.0).ToString("0.00",
                                                                                         System.Globalization.CultureInfo.InvariantCulture));
                    offset += 2;
                    break;

                case 'C':
                    line.Append(", " +
                                (BitConverter.ToUInt16(message, offset) / 100.0).ToString("0.00",
                                                                                          System.Globalization.CultureInfo.InvariantCulture));
                    offset += 2;
                    break;

                case 'e':
                    line.Append(", " +
                                (BitConverter.ToInt32(message, offset) / 100.0).ToString("0.00",
                                                                                         System.Globalization.CultureInfo.InvariantCulture));
                    offset += 4;
                    break;

                case 'E':
                    line.Append(", " +
                                (BitConverter.ToUInt32(message, offset) / 100.0).ToString("0.00",
                                                                                          System.Globalization.CultureInfo.InvariantCulture));
                    offset += 4;
                    break;

                case 'L':
                    line.Append(", " +
                                ((double)BitConverter.ToInt32(message, offset) / 10000000.0).ToString(
                                    System.Globalization.CultureInfo.InvariantCulture));
                    offset += 4;
                    break;

                case 'n':
                    line.Append(", " + ASCIIEncoding.ASCII.GetString(message, offset, 4).Trim(new char[] { '\0' }));
                    offset += 4;
                    break;

                case 'N':
                    line.Append(", " + ASCIIEncoding.ASCII.GetString(message, offset, 16).Trim(new char[] { '\0' }));
                    offset += 16;
                    break;

                case 'M':
                    int    modeno      = message[offset];
                    var    mode        = onFlightMode?.Invoke(_firmware, modeno);
                    string currentmode = mode == null?modeno.ToString() : mode;

                    line.Append(", " + currentmode);
                    offset++;
                    break;

                case 'Z':
                    line.Append(", " + ASCIIEncoding.ASCII.GetString(message, offset, 64).Trim(new char[] { '\0' }));
                    offset += 64;
                    break;

                case 'a':
                    line.Append(", [" + String.Join(" ", new UnionArray(message.Skip(offset).Take(64).ToArray()).Shorts.Take(32).ToList()) + "]");
                    offset += 2 * 32;
                    break;

                default:
                    return("Bad Conversion");
                }
            }

            return(line.ToString().Trim() + "\r\n");
        }
Beispiel #21
0
        /// <summary>
        /// Loads a .tex from memory and converts to bitmap
        /// </summary>
        /// <param name="data">raw tex data array</param>
        /// <param name="offset">offset into the array</param>
        /// <param name="count">number of bytes</param>
        /// <returns>bitmap of tex file.</returns>
        public Bitmap LoadFromTexMemory(byte[] data, int offset, int count)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }

            if (offset < 0 || offset > data.Length)
            {
                throw new ArgumentOutOfRangeException("offset");
            }

            if (count < 0 || (data.Length - offset) < count)
            {
                throw new ArgumentOutOfRangeException("count");
            }

            if (data.Length < 12)
            {
                Log.LogError("TEX is not long enough to be valid.");
                return(null);
            }

            if (BitConverter.ToUInt32(data, offset) != 0x01584554)
            {
                Log.LogError("Unexpected TEX magic found in game files, ignoring.");
                return(null);
            }

            // We need to convert from TEX to DDS format as follows:
            // The 1st 12 bytes of a TEX file is crap.  We want to throw it away
            // We need to change bytes 13,14,15,16 to: 0x44 0x44 0x53 0x20
            // We then create it from DDS memory starting at offset 12

            // I assume this is the texture offset. (Just add 12 to make it a file offset.)
            int textureOffset = BitConverter.ToInt32(data, offset + 4);

            System.Diagnostics.Debug.Assert(textureOffset == 0, "Texture Offset == 0");

            if (textureOffset < 0 || textureOffset > (count - offset))
            {
                throw new InvalidDataException("TEX texture offset is invalid.");
            }

            int textureLength = BitConverter.ToInt32(data, offset + 8);

            if (textureLength < 0 || textureLength > (count - offset - textureOffset))
            {
                throw new InvalidDataException("TEX texture length is invalid.");
            }

            if (textureLength < 4)
            {
                throw new InvalidDataException("Cannot read TEX texture image magic.");
            }

            int realOffset = offset + textureOffset + 12;

            // realOffset + 0           = DDSmagic "DDS " or "DDSR"
            //                            Following DDSmagic we have the DDS_HEADER structure.
            // realOffset + 4 + 0       = DDS_HEADER Structure size.  It should be 124 bytes unless its a DXT10 texture.
            //                            at offset 72 within DDS_HEADER we have the DDS_PIXELFORMAT structure.
            // realOffset + 8 + 0       = DDS_HEADER flags.
            // realOffset + 12 + 0      = DDS_HEADER Surface height (in pixels).
            // realOffset + 16 + 0      = DDS_HEADER Surface width (in pixels).
            // realOffset + 20 + 0      = DDS_HEADER Pitch Or LinearSize.
            // realOffset + 24 + 0      = DDS_HEADER Depth of a volume texture (in pixels).
            // realOffset + 28 + 0      = DDS_HEADER Number of mipmap levels
            // realOffset + 4 + 72 + 0  = DDS_PIXELFORMAT Structure size.  Should be 32 bytes.
            // realOffset + 4 + 72 + 4  = DDS_PIXELFORMAT Flags / 0x1 = DDPF_ALPHAPIXELS flag
            // realOffset + 4 + 72 + 8  = DDS_PIXELFORMAT FOURCC - Four-character codes for specifying compressed or custom formats.
            // realOffset + 4 + 72 + 12 = DDS_PIXELFORMAT RGBBitCount.  Make sure it's 32 bit since we have an alpha channel.
            // realOffset + 4 + 72 + 16 = Red Bitmask for A8R8G8B8 the red mask would be 0x00ff0000
            // realOffset + 4 + 72 + 20 = Green Bitmask for A8R8G8B8 the green mask would be 0x0000ff00.
            // realOffset + 4 + 72 + 24 = Blue Bitmask for A8R8G8B8 the blue mask would be 0x000000ff.
            // realOffset + 4 + 72 + 28 = Alpha Bitmask for A8R8G8B8 the alpha mask would be 0xff000000.
            // realOffset + 4 + 104     = DDS_HEADER Complexity of the surfaces stored.  Should always set at least 0x1000.
            uint textureMagic = BitConverter.ToUInt32(data, realOffset);

            // Check for both "DDS " and "DDSR".
            if ((textureMagic == 0x52534444 || textureMagic == 0x20534444) && textureLength >= 128)
            {
                // Make sure the DDS header is "valid".
                if (BitConverter.ToInt32(data, realOffset + 4) == 124 &&
                    BitConverter.ToInt32(data, realOffset + 76) == 32)
                {
                    // Copy the texture data to a new buffer and fix the magic so it is a valid DDS texture.
                    byte[] ddsData = new byte[textureLength];
                    Buffer.BlockCopy(data, realOffset, ddsData, 0, textureLength);

                    // Change "DDSR" to "DDS "
                    ddsData[3] = 0x20;

                    int bitDepth = BitConverter.ToInt32(ddsData, 88);
                    if (bitDepth >= 24)
                    {
                        // Set the Red pixel mask
                        ddsData[92] = 0;
                        ddsData[93] = 0;
                        ddsData[94] = 0xff;
                        ddsData[95] = 0;

                        // Set the Green pixel mask
                        ddsData[96] = 0;
                        ddsData[97] = 0xff;
                        ddsData[98] = 0;
                        ddsData[99] = 0;

                        // Set the Blue pixel mask
                        ddsData[100] = 0xff;
                        ddsData[101] = 0;
                        ddsData[102] = 0;
                        ddsData[103] = 0;

                        // HACK: Fix to make 32-bit DDS files use transparency.
                        if (bitDepth == 32)
                        {
                            // Add the alpha bit to the pixel format.
                            ddsData[80] |= 1;

                            // Set the Alpha pixel mask
                            ddsData[104] = 0;
                            ddsData[105] = 0;
                            ddsData[106] = 0;
                            ddsData[107] = 0xff;
                        }
                    }

                    // Set the DDS caps flag
                    ddsData[109] |= 0x10;

                    // now create it from this memory buffer
                    return(LoadFromMemory(ddsData, 0, ddsData.Length));
                }
                else
                {
                    throw new InvalidDataException("Invalid Header format.");
                }
            }
            else
            {
                throw new InvalidDataException("Unknown texture format.");
            }
        }
        /// <summary>
        /// Unwrap object wrapped in <see cref="SerializedObjectWrapper"/>
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        object Unwrap(SerializedObjectWrapper item)
        {
            if (item.Data.Array == null)
            {
                return(null);
            }

            if (item.Flags == RawDataFlag)
            {
                ArraySegment <byte> tmp = item.Data;

                if (tmp.Count == tmp.Array.Length)
                {
                    return(tmp.Array);
                }

                // we should never arrive here, but it's better to be safe than sorry
                var retval = new byte[tmp.Count];

                Array.Copy(tmp.Array, tmp.Offset, retval, 0, tmp.Count);

                return(retval);
            }

            var code = (TypeCode)(item.Flags & 0x00ff);

            byte[] data   = item.Data.Array;
            int    offset = item.Data.Offset;
            int    count  = item.Data.Count;

            switch (code)
            {
            // incrementing a non-existing key then getting it
            // returns as a string, but the flag will be 0
            // so treat all 0 flagged items as string
            // this may help inter-client data management as well
            //
            // however we store 'null' as Empty + an empty array,
            // so this must special-cased for compatibilty with
            // earlier versions. we introduced DBNull as null marker in emc2.6
            case TypeCode.Empty:
                return((data == null || count == 0)
                                                        ? null
                                                        : Encoding.UTF8.GetString(data, offset, count));

            case TypeCode.DBNull:
                return(null);

            case TypeCode.String:
                return(Encoding.UTF8.GetString(data, offset, count));

            case TypeCode.Boolean:
                return(BitConverter.ToBoolean(data, offset));

            case TypeCode.Int16:
                return(BitConverter.ToInt16(data, offset));

            case TypeCode.Int32:
                return(BitConverter.ToInt32(data, offset));

            case TypeCode.Int64:
                return(BitConverter.ToInt64(data, offset));

            case TypeCode.UInt16:
                return(BitConverter.ToUInt16(data, offset));

            case TypeCode.UInt32:
                return(BitConverter.ToUInt32(data, offset));

            case TypeCode.UInt64:
                return(BitConverter.ToUInt64(data, offset));

            case TypeCode.Char:
                return(BitConverter.ToChar(data, offset));

            case TypeCode.DateTime:
                return(DateTime.FromBinary(BitConverter.ToInt64(data, offset)));

            case TypeCode.Double:
                return(BitConverter.ToDouble(data, offset));

            case TypeCode.Single:
                return(BitConverter.ToSingle(data, offset));

            case TypeCode.Object:
                using (var ms = new MemoryStream(data, offset, count))
                {
                    return(bf.Deserialize(ms));
                }

            default: throw new InvalidOperationException("Unknown TypeCode was returned: " + code);
            }
        }
Beispiel #23
0
        /// <summary>A constructor to initialize a <c>new PairOfFiles</c>.</summary>
        /// <param name="FromStream"></param>
        /// <param name="SourceOrDestinationDrive"></param>
        /// <param name="TextEncoder"></param>
        public PairOfFiles(Stream FromStream, PairOfFiles ParentDirectory, bool isSource, TextConverter TextConverter) : this()
        {
            byte[] abBuffer, abTextBytes;
            ushort tTextLength;
            uint   uAttributes, uFirstBlock = 0;
            long   kCreationTimeTicks, kLastAccessTimeTicks, kLastWriteTimeTicks, kSize = -1;

            _ParentDirectory  = ParentDirectory;
            _SourceDrive      = _ParentDirectory.SourceDrive;
            _DestinationDrive = _ParentDirectory.DestinationDrive;
            _TextConverter    = TextConverter;
            abBuffer          = new byte[8];

            FromStream.Read(abBuffer, 0, 2);
            tTextLength = BitConverter.ToUInt16(abBuffer, 0);
            abTextBytes = new byte[tTextLength];
            FromStream.Read(abTextBytes, 0, tTextLength);
            _sRelativePath = _TextConverter.BytesToString(abTextBytes);

            FromStream.Read(abBuffer, 0, 4);
            uAttributes  = BitConverter.ToUInt32(abBuffer, 0);
            _isDirectory = ((uAttributes & (uint)FileAttributes.Directory) > 0);
            FromStream.Read(abBuffer, 0, 8);
            kCreationTimeTicks = BitConverter.ToInt64(abBuffer, 0);
            FromStream.Read(abBuffer, 0, 8);
            kLastAccessTimeTicks = BitConverter.ToInt64(abBuffer, 0);
            FromStream.Read(abBuffer, 0, 8);
            kLastWriteTimeTicks = BitConverter.ToInt64(abBuffer, 0);

            if (!_isDirectory)
            {
                FromStream.Read(abBuffer, 0, 8);
                kSize = BitConverter.ToInt64(abBuffer, 0);
                if ((isSource && (_SourceDrive.eEncryptionType == Drive.nEncryptionType.DirectorySymmetric)) || (!isSource && (_DestinationDrive.eEncryptionType == Drive.nEncryptionType.DirectorySymmetric)))
                {
                    FromStream.Read(abBuffer, 0, 4);
                    uFirstBlock = BitConverter.ToUInt32(abBuffer, 0);
                }
            }

            if (isSource)
            {
                _uAttributesSource    = uAttributes;
                _CreationTimeSource   = new DateTime(kCreationTimeTicks);
                _LastAccessTimeSource = new DateTime(kLastAccessTimeTicks);
                LastWriteTimeSource   = new DateTime(kLastWriteTimeTicks);
                _kSourceSize          = kSize;
                _sSourceSize          = FileSizeToString(kSize);
                _uFirstBlockSource    = uFirstBlock;
                _eComparison          = nComparison.UnknownDestination;
            }
            else
            {
                _uAttributesDestination    = uAttributes;
                _CreationTimeDestination   = new DateTime(kCreationTimeTicks);
                _LastAccessTimeDestination = new DateTime(kLastAccessTimeTicks);
                LastWriteTimeDestination   = new DateTime(kLastWriteTimeTicks);
                _kDestinationSize          = kSize;
                _sDestinationSize          = FileSizeToString(kSize);
                _uFirstBlockDestination    = uFirstBlock;
                _eComparison = nComparison.UnknownSource;
            }
        }
Beispiel #24
0
        public LevelDBBlockchain(string path)
        {
            header_index.Add(GenesisBlock.Hash);
            Slice value;

            db = DB.Open(path);
            if (db.TryGet(ReadOptions.Default, SliceBuilder.Begin(DataEntryPrefix.CFG_Initialized), out value) && value.ToBoolean())
            {
                ReadOptions options = new ReadOptions {
                    FillCache = false
                };
                value = db.Get(options, SliceBuilder.Begin(DataEntryPrefix.SYS_CurrentBlock));
                this.current_block_hash   = new UInt256(value.ToArray().Take(32).ToArray());
                this.current_block_height = BitConverter.ToUInt32(value.ToArray(), 32);
                foreach (Block header in db.Find(options, SliceBuilder.Begin(DataEntryPrefix.DATA_HeaderList), (k, v) =>
                {
                    using (MemoryStream ms = new MemoryStream(v.ToArray(), false))
                        using (BinaryReader r = new BinaryReader(ms))
                        {
                            return(new
                            {
                                Index = BitConverter.ToUInt32(k.ToArray(), 1),
                                Headers = r.ReadSerializableArray <Block>()
                            });
                        }
                }).OrderBy(p => p.Index).SelectMany(p => p.Headers).ToArray())
                {
                    if (header.Hash != GenesisBlock.Hash)
                    {
                        header_chain.Add(header.Hash, header, header.PrevBlock);
                        header_index.Add(header.Hash);
                    }
                    stored_header_count++;
                }
                if (stored_header_count == 0)
                {
                    Dictionary <UInt256, Block> table = db.Find(options, SliceBuilder.Begin(DataEntryPrefix.DATA_Block), (k, v) => Block.FromTrimmedData(v.ToArray(), 0)).ToDictionary(p => p.PrevBlock);
                    for (UInt256 hash = GenesisBlock.Hash; hash != current_block_hash;)
                    {
                        Block header = table[hash];
                        header_chain.Add(header.Hash, header, header.PrevBlock);
                        header_index.Add(header.Hash);
                        hash = header.Hash;
                    }
                }
                else if (current_block_height >= stored_header_count)
                {
                    List <Block> list = new List <Block>();
                    for (UInt256 hash = current_block_hash; hash != header_index[(int)stored_header_count - 1];)
                    {
                        Block header = Block.FromTrimmedData(db.Get(options, SliceBuilder.Begin(DataEntryPrefix.DATA_Block).Add(hash)).ToArray(), 0);
                        list.Add(header);
                        header_index.Insert((int)stored_header_count, hash);
                        hash = header.PrevBlock;
                    }
                    for (int i = list.Count - 1; i >= 0; i--)
                    {
                        header_chain.Add(list[i].Hash, list[i], list[i].PrevBlock);
                    }
                }
                this.current_header_hash = header_index[header_index.Count - 1];
            }
            else
            {
                WriteBatch  batch   = new WriteBatch();
                ReadOptions options = new ReadOptions {
                    FillCache = false
                };
                using (Iterator it = db.NewIterator(options))
                {
                    for (it.SeekToFirst(); it.Valid(); it.Next())
                    {
                        batch.Delete(it.Key());
                    }
                }
                batch.Put(SliceBuilder.Begin(DataEntryPrefix.CFG_Version), 0);
                db.Write(WriteOptions.Default, batch);
                Persist(GenesisBlock);
                db.Put(WriteOptions.Default, SliceBuilder.Begin(DataEntryPrefix.CFG_Initialized), true);
            }
            thread_persistence      = new Thread(PersistBlocks);
            thread_persistence.Name = "LevelDBBlockchain.PersistBlocks";
            thread_persistence.Start();
            AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
        }
Beispiel #25
0
        public async Task <bool> IsCorrectScreen(uint expectedScreen, CancellationToken token)
        {
            var data = await Connection.ReadBytesAsync(CurrentScreenOffset, 4, token).ConfigureAwait(false);

            return(BitConverter.ToUInt32(data, 0) == expectedScreen);
        }
Beispiel #26
0
        public static object GetValueObject(PropertyItem property)
        {
            if (property == null)
            {
                return(null);
            }
            switch ((PropertyTagType)property.Type)
            {
            //ASCII
            case PropertyTagType.ASCII:
                ASCIIEncoding encoding = new ASCIIEncoding();
                return(encoding.GetString(property.Value, 0, property.Len - 1));

            //BYTE
            case PropertyTagType.Byte:
                if (property.Len == 1)
                {
                    return(property.Value[0]);
                }
                else
                {
                    return(property.Value);
                }

            //LONG
            case PropertyTagType.Long:
                uint[] resultLong = new uint[property.Len / 4];
                for (int i = 0; i < resultLong.Length; i++)
                {
                    resultLong[i] = BitConverter.ToUInt32(property.Value, i * 4);
                }
                if (resultLong.Length == 1)
                {
                    return(resultLong[0]);
                }
                else
                {
                    return(resultLong);
                }

            //SHORT
            case PropertyTagType.Short:
                ushort[] resultShort = new ushort[property.Len / 2];
                for (int i = 0; i < resultShort.Length; i++)
                {
                    resultShort[i] = BitConverter.ToUInt16(property.Value, i * 2);
                }
                if (resultShort.Length == 1)
                {
                    return(resultShort[0]);
                }
                else
                {
                    return(resultShort);
                }

            //SLONG
            case PropertyTagType.SLONG:
                int[] resultSLong = new int[property.Len / 4];
                for (int i = 0; i < resultSLong.Length; i++)
                {
                    resultSLong[i] = BitConverter.ToInt32(property.Value, i * 4);
                }
                if (resultSLong.Length == 1)
                {
                    return(resultSLong[0]);
                }
                else
                {
                    return(resultSLong);
                }

            //RATIONAL
            case PropertyTagType.Rational:
                Fraction[] resultRational = new Fraction[property.Len / 8];
                uint       uNumerator;
                uint       uDenumerator;
                for (int i = 0; i < resultRational.Length; i++)
                {
                    uNumerator        = BitConverter.ToUInt32(property.Value, i * 8);
                    uDenumerator      = BitConverter.ToUInt32(property.Value, i * 8 + 4);
                    resultRational[i] = new Fraction(uNumerator, uDenumerator);
                }
                if (resultRational.Length == 1)
                {
                    return(resultRational[0]);
                }
                else
                {
                    return(resultRational);
                }

            //SRATIONAL
            case PropertyTagType.SRational:
                Fraction[] resultSRational = new Fraction[property.Len / 8];
                int        sNumerator;
                int        sDenumerator;
                for (int i = 0; i < resultSRational.Length; i++)
                {
                    sNumerator         = BitConverter.ToInt32(property.Value, i * 8);
                    sDenumerator       = BitConverter.ToInt32(property.Value, i * 8 + 4);
                    resultSRational[i] = new Fraction(sNumerator, sDenumerator);
                }
                if (resultSRational.Length == 1)
                {
                    return(resultSRational[0]);
                }
                else
                {
                    return(resultSRational);
                }

            //UNDEFINE
            default:
                if (property.Len == 1)
                {
                    return(property.Value[0]);
                }
                else
                {
                    return(property.Value);
                }
            }
        }
Beispiel #27
0
 /// <summary>
 /// Read int
 /// </summary>
 /// <returns></returns>
 public UInt32 ReadUInt32()
 {
     byte[] bytes = ReadByte(IntSize);
     return(BitConverter.ToUInt32(bytes, 0));
 }
 public override uint ReadUInt32() => BitConverter.ToUInt32(ReadRaw(sizeof(uint)), 0);
Beispiel #29
0
 uint UnpackUint32(byte[] buf, ref int offset)
 {
     uint value = BitConverter.ToUInt32(buf, offset);
     offset += 4;
     return value;
 }
Beispiel #30
0
        protected static T Read <T>(byte[] adata, ref int idx)
        {
            T res = default(T);

            // sizeof(T) on template does not work
            // SizeOf(T) (dynamic) apparently is not reliable - may return size of entire
            // container ther then storage size...
            // ...Surely, there must be more more sensible way of doing this...
            switch (Type.GetTypeCode(res.GetType()))
            {
            case TypeCode.UInt32:
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(adata, idx, 4);
                }
                res  = (T)Convert.ChangeType(BitConverter.ToUInt32(adata, idx), res.GetType());
                idx += 4;
                break;

            case TypeCode.Int32:
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(adata, idx, 4);
                }
                res  = (T)Convert.ChangeType(BitConverter.ToInt32(adata, idx), res.GetType());
                idx += 4;
                break;

            case TypeCode.UInt64:
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(adata, idx, 8);
                }
                res  = (T)Convert.ChangeType(BitConverter.ToUInt64(adata, idx), res.GetType());
                idx += 8;
                break;

            case TypeCode.Int64:
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(adata, idx, 8);
                }
                res  = (T)Convert.ChangeType(BitConverter.ToInt64(adata, idx), res.GetType());
                idx += 8;
                break;

            case TypeCode.UInt16:
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(adata, idx, 2);
                }
                res  = (T)Convert.ChangeType(BitConverter.ToUInt16(adata, idx), res.GetType());
                idx += 2;
                break;

            case TypeCode.Int16:
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(adata, idx, 2);
                }
                res  = (T)Convert.ChangeType(BitConverter.ToInt16(adata, idx), res.GetType());
                idx += 2;
                break;

            case TypeCode.Byte:
                res = (T)Convert.ChangeType(adata[idx++], res.GetType());
                break;

            // fallthrough are intentional here...
            case TypeCode.Boolean:
            case TypeCode.Char:
            case TypeCode.DateTime:
            case TypeCode.DBNull:
            case TypeCode.Decimal:
            case TypeCode.Double:
            case TypeCode.Empty:
            case TypeCode.Object:
            case TypeCode.SByte:
            case TypeCode.Single:
            case TypeCode.String:
            default:
                Logger.Warn($"{res.GetType()} Unsupported read type.");
                break;
            }



            return(res);
        }