Added raw UIX.RenderApi project

2026-07-27 13:13:10 -07:00 · 2021-07-11 22:59:29 -05:00
parent 6c9aacb510
commit 9fec520340
456 changed files with 45596 additions and 20 deletions
@@ -0,0 +1,176 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Render.Protocol.MarshalHelper
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Microsoft.Iris.Render.Protocol
+{
+  internal class MarshalHelper
+  {
+    private static RENDERHANDLE[] s_EmptyRenderHandleArray = new RENDERHANDLE[0];
+
+    public static unsafe void Decode(
+      RenderPort port,
+      Message* pmsg,
+      BLOBREF refParam,
+      out string param)
+    {
+      uint uint32 = BLOBREF.ToUInt32(refParam);
+      uint num1 = uint32 & (uint) ushort.MaxValue;
+      uint num2 = (uint32 & 4294901760U) >> 16;
+      byte* numPtr = (byte*) ((IntPtr) pmsg + (int) num1);
+      int length = (int) num2 - 2;
+      byte[] numArray = new byte[length];
+      Marshal.Copy(new IntPtr((void*) numPtr), numArray, 0, length);
+      Encoding encoding = Encoding.Unicode;
+      if (port.AlwaysBigEndian)
+        encoding = Encoding.BigEndianUnicode;
+      param = encoding.GetString(numArray);
+    }
+
+    public static unsafe void Decode(
+      RenderPort port,
+      Message* pmsgOuter,
+      BLOBREF refMsgInner,
+      out Message* pmsgInner)
+    {
+      byte* numPtr = (byte*) pmsgOuter;
+      uint num = (uint) ushort.MaxValue & BLOBREF.ToUInt32(refMsgInner);
+      pmsgInner = (Message*) (numPtr + (int) num);
+    }
+
+    private static ushort[] ComputeByteOrderMap(Type targetType, bool fCompact)
+    {
+      ushort[] fieldMap = new ushort[10];
+      MarshalHelper.ComputeByteOrderMapWorker(ref fieldMap, targetType, 0);
+      if (fCompact)
+      {
+        int length = (int) fieldMap[0] + 1;
+        if (fieldMap.Length > length)
+        {
+          ushort[] numArray = new ushort[length];
+          Array.Copy((Array) fieldMap, (Array) numArray, length);
+          fieldMap = numArray;
+        }
+      }
+      return fieldMap;
+    }
+
+    public static unsafe void SwapByteOrder(
+      byte* pMem,
+      ref ushort[] fieldMapByRef,
+      Type type,
+      int startOffset,
+      int stopOffset)
+    {
+      if (fieldMapByRef == null)
+        fieldMapByRef = MarshalHelper.ComputeByteOrderMap(type, true);
+      ushort[] numArray = fieldMapByRef;
+      if (stopOffset <= 0)
+        stopOffset = int.MaxValue;
+      int num1 = (int) numArray[0] + 1;
+      for (int index1 = 1; index1 < num1; ++index1)
+      {
+        ushort num2 = numArray[index1];
+        int num3 = (int) num2 >> 2;
+        if (num3 >= startOffset)
+        {
+          if (num3 >= stopOffset)
+            break;
+          int num4 = 1 << ((int) num2 & 3);
+          byte* numPtr = pMem + num3;
+          int num5 = num4 / 2;
+          for (int index2 = 0; index2 < num5; ++index2)
+          {
+            int index3 = num4 - (index2 + 1);
+            byte num6 = numPtr[index2];
+            numPtr[index2] = numPtr[index3];
+            numPtr[index3] = num6;
+          }
+        }
+      }
+    }
+
+    public static object MakeDumpable(string value) => (object) value;
+
+    public static object MakeDumpable(object value) => value;
+
+    public static unsafe object MakeDumpable(void* value) => (object) new IntPtr(value);
+
+    private static void ComputeByteOrderMapWorker(
+      ref ushort[] fieldMap,
+      Type targetType,
+      int parentOffset)
+    {
+      if (targetType.IsPrimitive)
+        return;
+      int packingForType = MarshalHelper.GetPackingForType(targetType);
+      int num1 = 0;
+      foreach (FieldInfo field in targetType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
+      {
+        Type type = field.FieldType;
+        if (type.IsEnum)
+          type = Enum.GetUnderlyingType(type);
+        int size = Marshal.SizeOf(type);
+        int num2 = size;
+        if (type.IsPrimitive)
+        {
+          if (num2 > packingForType)
+            num2 = packingForType;
+        }
+        else if (num2 > 4)
+          num2 = 4;
+        int num3 = num2 - 1;
+        int num4 = num1 + num3 & ~num3;
+        int num5 = num4 + parentOffset;
+        if (type.IsPrimitive)
+          MarshalHelper.AddByteOrderEntry(ref fieldMap, num5, size);
+        else
+          MarshalHelper.ComputeByteOrderMapWorker(ref fieldMap, type, num5);
+        num1 = num4 + size;
+      }
+    }
+
+    private static int GetPackingForType(Type t) => 8;
+
+    private static void AddByteOrderEntry(ref ushort[] fieldMap, int offset, int size)
+    {
+      ushort num;
+      switch (size)
+      {
+        case 1:
+          return;
+        case 2:
+          num = (ushort) 1;
+          break;
+        case 3:
+          return;
+        case 4:
+          num = (ushort) 2;
+          break;
+        case 8:
+          num = (ushort) 3;
+          break;
+        default:
+          return;
+      }
+      int index = (int) fieldMap[0] + 1;
+      if (index >= fieldMap.Length)
+      {
+        ushort[] numArray = new ushort[2 * fieldMap.Length];
+        Array.Copy((Array) fieldMap, (Array) numArray, fieldMap.Length);
+        fieldMap = numArray;
+      }
+      fieldMap[0] = (ushort) index;
+      fieldMap[index] = (ushort) ((uint) (offset << 2) | (uint) num);
+    }
+
+    public static RENDERHANDLE[] CreateRenderHandleArray(int length) => length == 0 ? MarshalHelper.s_EmptyRenderHandleArray : new RENDERHANDLE[length];
+  }
+}