Beispiel #1
0
        private static Type getType(UDKFile udk, int type)
        {
            switch (udk.getName(type))
            {
            case "None": return(Type.None);

            case "StructProperty": return(Type.StructProperty);

            case "IntProperty": return(Type.IntProperty);

            case "FloatProperty": return(Type.FloatProperty);

            case "ObjectProperty": return(Type.ObjectProperty);

            case "NameProperty": return(Type.NameProperty);

            case "BoolProperty": return(Type.BoolProperty);

            case "ByteProperty": return(Type.ByteProperty);

            case "ArrayProperty": return(Type.ArrayProperty);

            case "DelegateProperty": return(Type.DelegateProperty);

            case "StrProperty": return(Type.StrProperty);

            default:
                return(Type.Unknown);
            }
        }
Beispiel #2
0
        public static List <Property> getPropList(UDKFile udk, UDKFile.ExportEntry export)
        {
            Application.DoEvents();
            int start = detectStart(udk, export.Data, export.ObjectFlags);

            return(ReadProp(udk, export.Data, start));
        }
Beispiel #3
0
 public ExportEntry(UDKFile udkFile, byte[] importData, uint exportOffset)
 {
     udkRef     = udkFile;
     header     = (byte[])importData.Clone();
     offset     = exportOffset;
     hasChanged = false;
 }
Beispiel #4
0
        public static Property getPropOrNull(UDKFile udk, byte[] data, int start, string propName)
        {
            List <Property> props = ReadProp(udk, data, start);

            foreach (Property prop in props)
            {
                if (udk.getName(prop.Name) == propName)
                {
                    return(prop);
                }
            }
            return(null);
        }
 public InterpreterHost(UDKFile udk, int index)
 {
     InitializeComponent();
     string className = udk.Exports[index].ClassName;
     interpreter1.Pcc = udk;
     interpreter1.Index = index;
     interpreter1.InitInterpreter();
     toolStripStatusLabel1.Text = "Class: " + className + ", Export Index: " + index;
     toolStripStatusLabel2.Text = "@" + Path.GetFileName(udk.FileName);
     interpreter1.hb1.ReadOnly = true;
     interpreter1.saveHexButton.Visible = false;
     interpreter1.exportButton.Visible = true;
 }
Beispiel #6
0
        public static Property getPropOrNull(UDKFile udk, UDKFile.ExportEntry export, string propName)
        {
            List <Property> props = getPropList(udk, export);

            foreach (Property prop in props)
            {
                if (udk.getName(prop.Name) == propName)
                {
                    return(prop);
                }
            }
            return(null);
        }
Beispiel #7
0
        public static string PropertyToText(Property p, UDKFile udk)
        {
            string s = "";

            s  = "Name: " + udk.getName(p.Name);
            s += " Type: " + TypeToString((int)p.TypeVal);
            s += " Size: " + p.Value.len;
            switch (p.TypeVal)
            {
            case Type.StructProperty:
                s += " \"" + udk.getName(p.Value.IntValue) + "\" with " + p.Value.Array.Count + " bytes";
                break;

            case Type.IntProperty:
            case Type.ObjectProperty:
            case Type.BoolProperty:
                s += " Value: " + p.Value.IntValue;
                break;

            case Type.FloatProperty:
                byte[] buff = BitConverter.GetBytes(p.Value.IntValue);
                float  f    = BitConverter.ToSingle(buff, 0);
                s += " Value: " + f;
                break;

            case Type.NameProperty:
                s += " " + udk.getName(p.Value.IntValue);
                break;

            case Type.ByteProperty:
                s += " Value: \"" + p.Value.StringValue + "\" with \"" + udk.getName(p.Value.IntValue) + "\"";
                break;

            case Type.ArrayProperty:
                s += " bytes";     //Value: " + p.Value.Array.Count.ToString() + " Elements";
                break;

            case Type.StrProperty:
                if (p.Value.StringValue.Length == 0)
                {
                    break;
                }
                s += " Value: " + p.Value.StringValue.Substring(0, p.Value.StringValue.Length - 1);
                break;
            }
            return(s);
        }
Beispiel #8
0
        public static List <List <Property> > ReadStructArrayProp(UDKFile udk, Property p)
        {
            List <List <Property> > res = new List <List <Property> >();
            int pos       = 28;
            int linkCount = BitConverter.ToInt32(p.raw, 24);

            for (int i = 0; i < linkCount; i++)
            {
                List <Property> p2 = ReadProp(udk, p.raw, pos);
                for (int j = 0; j < p2.Count(); j++)
                {
                    pos += p2[j].raw.Length;
                }
                res.Add(p2);
            }
            return(res);
        }
Beispiel #9
0
        public static int detectStart(UDKFile udk, byte[] raw, ulong flags)
        {
            if ((flags & (ulong)UnrealFlags.EObjectFlags.HasStack) != 0)
            {
                return(26);
            }
            int result = 8;
            int test1  = BitConverter.ToInt32(raw, 4);
            int test2  = BitConverter.ToInt32(raw, 8);

            if (udk.isName(test1) && test2 == 0)
            {
                result = 4;
            }
            if (udk.isName(test1) && udk.isName(test2) && test2 != 0)
            {
                result = 8;
            }
            return(result);
        }
Beispiel #10
0
        private static PropertyValue ReadValue(UDKFile udk, byte[] raw, int start, int type)
        {
            PropertyValue v = new PropertyValue();

            switch (udk.getName(type))
            {
            case "IntProperty":
            case "FloatProperty":
            case "ObjectProperty":
            case "StringRefProperty":
                v.IntValue = BitConverter.ToInt32(raw, start);
                v.len      = 4;
                break;

            case "NameProperty":
                v.IntValue = BitConverter.ToInt32(raw, start);
                var nameRef = new NameReference();
                nameRef.index = v.IntValue;
                nameRef.count = BitConverter.ToInt32(raw, start + 4);
                nameRef.Name  = udk.getName(nameRef.index);
                if (nameRef.count > 0)
                {
                    nameRef.Name += "_" + (nameRef.count - 1);
                }
                v.NameValue = nameRef;
                v.len       = 8;
                break;

            case "BoolProperty":
                if (start < raw.Length)
                {
                    v.IntValue = raw[start];
                }
                v.len = 1;
                break;
            }
            return(v);
        }
 public void LoadFile(string s, bool isfromdlc = false)
 {
     try
     {
         currentFile = s;
         udk = new UDKFile(s);
         haveCloned = false;
         appendSaveMenuItem.Enabled = true;
         appendSaveMenuItem.ToolTipText = "Save by appending changes to the end of the file";
         interpreterControl.Pcc = udk;
         treeView1.Tag = udk;
         RefreshView();
         InitStuff();
         if (!isfromdlc)
             status2.Text = "@" + Path.GetFileName(s);
         else
             status2.Text = "@" + inDLCFilename;
         IsFromDLC = isfromdlc;
     }
     catch (Exception e)
     {
         MessageBox.Show("Error:\n" + e.Message);
     }
 }
 private static Type getType(UDKFile udk, int type)
 {
     switch (udk.getName(type))
     {
         case "None": return Type.None;
         case "StructProperty": return Type.StructProperty;
         case "IntProperty": return Type.IntProperty;
         case "FloatProperty": return Type.FloatProperty;
         case "ObjectProperty": return Type.ObjectProperty;
         case "NameProperty": return Type.NameProperty;
         case "BoolProperty": return Type.BoolProperty;
         case "ByteProperty": return Type.ByteProperty;
         case "ArrayProperty": return Type.ArrayProperty;
         case "DelegateProperty": return Type.DelegateProperty;
         case "StrProperty": return Type.StrProperty;             
         default:
             return Type.Unknown;
     }
 }
        public static List<Property> ReadProp(UDKFile udk, byte[] raw, int start)
        {
            Property p;
            PropertyValue v;
            int sname;
            List<Property> result = new List<Property>();
            int pos = start;
            if(raw.Length - pos < 8)
                return result;
            int name = (int)BitConverter.ToInt64(raw, pos);
            if (!udk.isName(name))
                return result;
            string t = udk.getName(name);
            if (udk.getName(name) == "None")
            {
                p = new Property();
                p.Name = name;
                p.TypeVal = Type.None;
                p.i = 0;                
                p.offsetval = pos;
                p.Size = 8;
                p.Value = new PropertyValue();
                p.raw = BitConverter.GetBytes((Int64)name);
                p.offend = pos + 8;
                result.Add(p);
                return result;
            }
            int type = (int)BitConverter.ToInt64(raw, pos + 8);            
            int size = BitConverter.ToInt32(raw, pos + 16);
            int idx = BitConverter.ToInt32(raw, pos + 20);
            if (!udk.isName(type) || size < 0 || size >= raw.Length)
                return result;
            string tp = udk.getName(type);
            switch (tp)
            {

                case "DelegateProperty":
                    p = new Property();
                    p.Name = name;
                    p.TypeVal = Type.DelegateProperty;
                    p.i = 0;
                    p.offsetval = pos + 24;
                    v = new PropertyValue();
                    v.IntValue = BitConverter.ToInt32(raw, pos + 28);
                    v.len = size;
                    v.Array = new List<PropertyValue>();
                    pos += 24;
                    for (int i = 0; i < size; i++)
                    {
                        PropertyValue v2 = new PropertyValue();
                        if(pos < raw.Length)
                            v2.IntValue = raw[pos];
                        v.Array.Add(v2);
                        pos ++;
                    }
                    p.Value = v;
                    break;
                case "ArrayProperty":
                    int count = (int)BitConverter.ToInt64(raw, pos + 24);
                    p = new Property();
                    p.Name = name;
                    p.TypeVal = Type.ArrayProperty;
                    p.i = 0;
                    p.offsetval = pos + 24;
                    v = new PropertyValue();
                    v.IntValue = type;
                    v.len = size - 4;
                    count = v.len;//TODO can be other objects too
                    v.Array = new List<PropertyValue>();
                    pos += 28;
                    for (int i = 0; i < count; i++)
                    {
                        PropertyValue v2 = new PropertyValue();
                        if(pos < raw.Length)
                            v2.IntValue = raw[pos];
                        v.Array.Add(v2);
                        pos ++;
                    }
                    p.Value = v;
                    break;
                case "StrProperty":
                    count = (int)BitConverter.ToInt64(raw, pos + 24);
                    p = new Property();
                    p.Name = name;
                    p.TypeVal = Type.StrProperty;
                    p.i = 0;
                    p.offsetval = pos + 24;
                    v = new PropertyValue();
                    v.IntValue = type;
                    v.len = count;
                    pos += 28;
                    string s = "";
                    for (int i = 0; i < count; i++)
                    {
                        s += (char)raw[pos];
                        pos += 1;
                    }
                    v.StringValue = s;
                    p.Value = v;
                    break;
                case "StructProperty":
                    sname = (int)BitConverter.ToInt64(raw, pos + 24);
                    p = new Property();
                    p.Name = name;
                    p.TypeVal = Type.StructProperty;
                    p.i = 0;
                    p.offsetval = pos + 24;
                    v = new PropertyValue();
                    v.IntValue = sname;
                    v.len = size;
                    v.Array = new List<PropertyValue>();
                    pos += 32;
                    for (int i = 0; i < size; i++)
                    {
                        PropertyValue v2 = new PropertyValue();
                        if (pos < raw.Length)
                            v2.IntValue = raw[pos];
                        v.Array.Add(v2);
                        pos++;
                    }
                    p.Value = v;
                    break;
                case "ByteProperty":
                    sname = (int)BitConverter.ToInt64(raw, pos + 24);
                    p = new Property();
                    p.Name = name;
                    p.TypeVal = Type.ByteProperty;
                    p.i = 0;
                    p.offsetval = pos + 32;
                    v = new PropertyValue();
                    v.StringValue = udk.getName(sname);
                    v.len = size;
                    pos += 32;
                    if (size == 8)
                    {
                        v.IntValue = BitConverter.ToInt32(raw, pos);
                    }
                    else
                    {
                        v.IntValue = raw[pos];
                    }
                    pos += size;
                    p.Value = v;
                    break;                     
                default:
                    p = new Property();
                    p.Name = name;
                    p.TypeVal = getType(udk,type);
                    p.i = 0;
                    p.offsetval = pos + 24;
                    p.Value = ReadValue(udk, raw, pos + 24, type);
                    pos += p.Value.len + 24;
                    break;
            }
            p.Size = size;
            p.raw = new byte[pos - start];
            p.offend = pos;
            if(pos < raw.Length)
                for (int i = 0; i < pos - start; i++) 
                    p.raw[i] = raw[start + i];
            result.Add(p);            
            if(pos!=start) result.AddRange(ReadProp(udk, raw, pos));
            return result;
        }
Beispiel #14
0
 public ImportEntry(UDKFile udkFile, byte[] importData)
 {
     udkRef = udkFile;
     header = (byte[])importData.Clone();
 }
 public static List<Property> getPropList(UDKFile udk, UDKFile.ExportEntry export)
 {
     Application.DoEvents();
     int start = detectStart(udk, export.Data, export.ObjectFlags);
     return ReadProp(udk, export.Data, start);
 }
 private bool importTree(TreeNode sourceNode, UDKFile importudk, int n)
 {
     int nextIndex;
     int index;
     foreach (TreeNode node in sourceNode.Nodes)
     {
         index = Convert.ToInt32(node.Name);
         if (index >= 0)
         {
             if(!importExport(importudk, index, n))
             {
                 return false;
             }
             nextIndex = udk.Exports.Count;
         }
         else
         {
             importImport(importudk, -index - 1, n);
             nextIndex = -udk.Imports.Count;
         }
         if (node.Nodes.Count > 0)
         {
             if(!importTree(node, importudk, nextIndex))
             {
                 return false;
             }
         }
     }
     return true;
 }
        private bool importExport(UDKFile importudk, int n, int link)
        {
            UDKFile.ExportEntry ex = importudk.Exports[n];
            UDKFile.ExportEntry nex = new UDKFile.ExportEntry();
            byte[] idata = ex.Data;
            List<PropertyReader.Property> Props = PropertyReader.getPropList(importudk, ex);
            int start = PropertyReader.detectStart(importudk, idata, importudk.Exports[n].ObjectFlags);
            int end = start;
            if (Props.Count != 0)
            {
                end = Props[Props.Count - 1].offend;
            }
            MemoryStream res = new MemoryStream();
            if ((importudk.Exports[n].ObjectFlags & (ulong)UnrealFlags.EObjectFlags.HasStack) != 0)
            {
                byte[] stackdummy = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, //Lets hope for the best :D
                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,};
                res.Write(stackdummy, 0, stackdummy.Length);
            }
            else
            {
                res.Write(new byte[start], 0, start);
            }
            //store copy of names list in case something goes wrong
            List<UDKFile.NameEntry> names = udk.Names.ToList();
            try
            {
                foreach (PropertyReader.Property p in Props)
                {
                    PropertyReader.ImportProperty(udk, importudk, p, importudk.getObjectName(ex.idxClass), res);
                }
            }
            catch (Exception exception)
            {
                //restore namelist
                udk.Names = names;
                MessageBox.Show("Error occured while trying to import " + ex.ObjectName + " : " + exception.Message);
                return false;
            }

            for (int i = end; i < idata.Length; i++)
                res.WriteByte(idata[i]);

            nex.header = (byte[])ex.header.Clone();
            nex.Data = res.ToArray();
            nex.DataSize = nex.Data.Length;
            nex.idxObjectName = udk.FindNameOrAdd(importudk.getName(ex.idxObjectName));
            nex.idxLink = link;
            nex.idxArchtype = nex.idxClass = nex.idxClassParent = 0;
            nex.udkRef = udk;
            udk.addExport(nex);
            return true;
        }
 public static string PropertyToText(Property p,UDKFile udk)
 {
     string s = "";
     s = "Name: " + udk.getName(p.Name);
     s += " Type: " + TypeToString((int)p.TypeVal);
     s += " Size: " + p.Value.len;
     switch (p.TypeVal)
     {
         case Type.StructProperty:
             s += " \"" + udk.getName (p.Value.IntValue) + "\" with " + p.Value.Array.Count + " bytes";
             break;
         case Type.IntProperty:                
         case Type.ObjectProperty:
         case Type.BoolProperty:
             s += " Value: " + p.Value.IntValue;
             break;
         case Type.FloatProperty:
             byte[] buff = BitConverter.GetBytes(p.Value.IntValue);
             float f = BitConverter.ToSingle(buff,0);
             s += " Value: " + f;
             break;
         case Type.NameProperty:
             s += " " + udk.getName(p.Value.IntValue);
             break;
         case Type.ByteProperty:
             s += " Value: \"" + p.Value.StringValue + "\" with \"" + udk.getName(p.Value.IntValue) + "\"";
             break;
         case Type.ArrayProperty:
             s += " bytes"; //Value: " + p.Value.Array.Count.ToString() + " Elements";
             break;
         case Type.StrProperty:
             if (p.Value.StringValue.Length == 0)
                 break;
             s += " Value: " + p.Value.StringValue.Substring(0,p.Value.StringValue.Length - 1);
             break;
     }
     return s;
 }
Beispiel #19
0
 public ImportEntry(UDKFile udkFile, Stream importData)
 {
     udkRef = udkFile;
     header = new byte[ImportEntry.byteSize];
     importData.Read(header, 0, header.Length);
 }
 public static int detectStart(UDKFile udk, byte[] raw, ulong flags)
 {
     if ((flags & (ulong)UnrealFlags.EObjectFlags.HasStack) != 0)
     {
         return 26;
     }
     int result = 8;
     int test1 = BitConverter.ToInt32(raw, 4);
     int test2 = BitConverter.ToInt32(raw, 8);
     if (udk.isName(test1) && test2 == 0)
         result = 4;
     if (udk.isName(test1) && udk.isName(test2) && test2 != 0)
         result = 8;    
     return result;
 }
 public static Property getPropOrNull(UDKFile udk, UDKFile.ExportEntry export, string propName)
 {
     List<Property> props = getPropList(udk, export);
     foreach (Property prop in props)
     {
         if (udk.getName(prop.Name) == propName)
         {
             return prop;
         }
     }
     return null;
 }
Beispiel #22
0
        public void addImport(UDKFile.ImportEntry importEntry)
        {
            if (importEntry.udkRef != this)
                throw new Exception("you cannot add a new import entry from another udk file, it has invalid references!");

            Imports.Add(importEntry);
            ImportCount = Imports.Count;
        }
Beispiel #23
0
 public ExportEntry(UDKFile udkFile, byte[] importData, uint exportOffset)
 {
     udkRef = udkFile;
     header = (byte[])importData.Clone();
     offset = exportOffset;
     hasChanged = false;
 }
Beispiel #24
0
 public ImportEntry(UDKFile udkFile, Stream importData)
 {
     udkRef = udkFile;
     header = new byte[ImportEntry.byteSize];
     importData.Read(header, 0, header.Length);
 }
Beispiel #25
0
        public static void ImportProperty(UDKFile udk, UDKFile importudk, Property p, string className, System.IO.MemoryStream m, bool inStruct = false)
        {
            string name    = importudk.getName(p.Name);
            int    idxname = udk.FindNameOrAdd(name);

            m.Write(BitConverter.GetBytes(idxname), 0, 4);
            m.Write(new byte[4], 0, 4);
            if (name == "None")
            {
                return;
            }
            string type    = importudk.getName(BitConverter.ToInt32(p.raw, 8));
            int    idxtype = udk.FindNameOrAdd(type);

            m.Write(BitConverter.GetBytes(idxtype), 0, 4);
            m.Write(new byte[4], 0, 4);
            string          name2;
            int             idxname2;
            int             size, count, pos;
            List <Property> Props;

            switch (type)
            {
            case "IntProperty":
            case "FloatProperty":
            case "ObjectProperty":
            case "NameProperty":
                m.Write(BitConverter.GetBytes(8), 0, 4);
                m.Write(new byte[4], 0, 4);
                m.Write(BitConverter.GetBytes(udk.FindNameOrAdd(importudk.getName(p.Value.IntValue))), 0, 4);
                //preserve index or whatever the second part of a namereference is
                m.Write(p.raw, 28, 4);
                break;

            case "BoolProperty":
                m.Write(new byte[8], 0, 8);
                m.WriteByte((byte)p.Value.IntValue);
                break;

            case "ByteProperty":
                name2    = importudk.getName(BitConverter.ToInt32(p.raw, 24));
                idxname2 = udk.FindNameOrAdd(name2);
                m.Write(BitConverter.GetBytes(p.Size), 0, 4);
                m.Write(new byte[4], 0, 4);
                m.Write(BitConverter.GetBytes(idxname2), 0, 4);
                m.Write(new byte[4], 0, 4);
                if (p.Size == 8)
                {
                    m.Write(BitConverter.GetBytes(udk.FindNameOrAdd(importudk.getName(p.Value.IntValue))), 0, 4);
                    m.Write(new byte[4], 0, 4);
                }
                else
                {
                    m.WriteByte(p.raw[32]);
                }
                break;

            case "DelegateProperty":
                size = BitConverter.ToInt32(p.raw, 16);
                if (size == 0xC)
                {
                    name2    = importudk.getName(BitConverter.ToInt32(p.raw, 28));
                    idxname2 = udk.FindNameOrAdd(name2);
                    m.Write(BitConverter.GetBytes(0xC), 0, 4);
                    m.Write(new byte[4], 0, 4);
                    m.Write(new byte[4], 0, 4);
                    m.Write(BitConverter.GetBytes(idxname2), 0, 4);
                    m.Write(new byte[4], 0, 4);
                }
                else
                {
                    m.Write(BitConverter.GetBytes(size), 0, 4);
                    m.Write(new byte[4], 0, 4);
                    for (int i = 0; i < size; i++)
                    {
                        m.WriteByte(p.raw[24 + i]);
                    }
                }
                break;

            case "StrProperty":
                name2 = p.Value.StringValue;
                m.Write(BitConverter.GetBytes(4 + name2.Length), 0, 4);
                m.Write(new byte[4], 0, 4);
                m.Write(BitConverter.GetBytes(name2.Length), 0, 4);
                foreach (char c in name2)
                {
                    m.WriteByte((byte)c);
                }
                break;

            case "StructProperty":
                size     = BitConverter.ToInt32(p.raw, 16);
                name2    = importudk.getName(BitConverter.ToInt32(p.raw, 24));
                idxname2 = udk.FindNameOrAdd(name2);
                pos      = 32;
                Props    = new List <Property>();
                try
                {
                    Props = ReadProp(importudk, p.raw, pos);
                }
                catch (Exception)
                {
                }
                m.Write(BitConverter.GetBytes(size), 0, 4);
                m.Write(new byte[4], 0, 4);
                m.Write(BitConverter.GetBytes(idxname2), 0, 4);
                m.Write(new byte[4], 0, 4);
                if (Props.Count == 0 || Props[0].TypeVal == Type.Unknown)
                {
                    for (int i = 0; i < size; i++)
                    {
                        m.WriteByte(p.raw[32 + i]);
                    }
                }
                else
                {
                    foreach (Property pp in Props)
                    {
                        ImportProperty(udk, importudk, pp, className, m, inStruct);
                    }
                }
                break;

            case "ArrayProperty":
                size  = BitConverter.ToInt32(p.raw, 16);
                count = BitConverter.ToInt32(p.raw, 24);
                PropertyInfo info      = getPropertyInfo(className, name, inStruct);
                ArrayType    arrayType = getArrayType(info);
                pos = 28;
                List <Property> AllProps = new List <Property>();

                if (arrayType == ArrayType.Struct)
                {
                    for (int i = 0; i < count; i++)
                    {
                        Props = new List <Property>();
                        try
                        {
                            Props = ReadProp(importudk, p.raw, pos);
                        }
                        catch (Exception)
                        {
                        }
                        AllProps.AddRange(Props);
                        if (Props.Count != 0)
                        {
                            pos = Props[Props.Count - 1].offend;
                        }
                    }
                }
                m.Write(BitConverter.GetBytes(size), 0, 4);
                m.Write(new byte[4], 0, 4);
                m.Write(BitConverter.GetBytes(count), 0, 4);
                if (AllProps.Count != 0 && (info == null || !isImmutable(info.reference)))
                {
                    foreach (Property pp in AllProps)
                    {
                        ImportProperty(udk, importudk, pp, className, m, inStruct);
                    }
                }
                else if (arrayType == ArrayType.Name)
                {
                    for (int i = 0; i < count; i++)
                    {
                        string s = importudk.getName(BitConverter.ToInt32(p.raw, 28 + i * 8));
                        m.Write(BitConverter.GetBytes(udk.FindNameOrAdd(s)), 0, 4);
                        //preserve index or whatever the second part of a namereference is
                        m.Write(p.raw, 32 + i * 8, 4);
                    }
                }
                else
                {
                    m.Write(p.raw, 28, size - 4);
                }
                break;

            default:
                throw new Exception(type);
            }
        }
 public static List<List<Property>> ReadStructArrayProp(UDKFile udk, Property p)
 {
     List<List<Property>> res = new List<List<Property>>();
     int pos = 28;
     int linkCount = BitConverter.ToInt32(p.raw, 24);
     for (int i = 0; i < linkCount; i++)
     {
         List<Property> p2 = ReadProp(udk, p.raw, pos);
         for (int j = 0; j < p2.Count(); j++)
         {
             pos += p2[j].raw.Length;
         }
         res.Add(p2);
     }
     return res;
 }
Beispiel #27
0
 public ImportEntry(UDKFile udkFile, byte[] importData)
 {
     udkRef = udkFile;
     header = (byte[])importData.Clone();
 }
Beispiel #28
0
        public static ME3LibWV.CustomProperty PropertyToGrid(Property p, UDKFile udk)
        {
            string cat = p.TypeVal.ToString();

            ME3LibWV.CustomProperty pg;
            NameProp pp;

            switch (p.TypeVal)
            {
            case Type.BoolProperty:
                pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, (p.Value.IntValue == 1), typeof(bool), false, true);
                break;

            case Type.FloatProperty:
                byte[] buff = BitConverter.GetBytes(p.Value.IntValue);
                float  f    = BitConverter.ToSingle(buff, 0);
                pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, f, typeof(float), false, true);
                break;

            case Type.ByteProperty:
                if (p.Size != 8)
                {
                    pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, (byte)p.Value.IntValue, typeof(byte), false, true);
                }
                else
                {
                    pp           = new NameProp();
                    pp.name      = udk.getName(p.Value.IntValue);
                    pp.nameindex = p.Value.IntValue;
                    pg           = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, pp, typeof(NameProp), false, true);
                }
                break;

            case Type.NameProperty:
                pp           = new NameProp();
                pp.name      = udk.getName(p.Value.IntValue);
                pp.nameindex = p.Value.IntValue;
                pg           = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, pp, typeof(NameProp), false, true);
                break;

            case Type.ObjectProperty:
                ObjectProp ppo = new ObjectProp();
                ppo.objectName = udk.getObjectName(p.Value.IntValue);
                ppo.index      = p.Value.IntValue;
                pg             = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, ppo, typeof(ObjectProp), false, true);
                break;

            case Type.StrProperty:
                pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, p.Value.StringValue, typeof(string), false, true);
                break;

            case Type.ArrayProperty:
                pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, BitConverter.ToInt32(p.raw, 24) + " elements", typeof(string), false, true);
                break;

            case Type.StructProperty:
                string structType = udk.getName(p.Value.IntValue);
                if (structType == "Color")
                {
                    ColorProp cp = new ColorProp();
                    cp.name      = structType;
                    cp.nameindex = p.Value.IntValue;
                    System.Drawing.Color color = System.Drawing.Color.FromArgb(BitConverter.ToInt32(p.raw, 32));
                    cp.Alpha = color.A;
                    cp.Red   = color.R;
                    cp.Green = color.G;
                    cp.Blue  = color.B;
                    pg       = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, cp, typeof(ColorProp), false, true);
                }
                else if (structType == "Vector")
                {
                    VectorProp vp = new VectorProp();
                    vp.name      = structType;
                    vp.nameindex = p.Value.IntValue;
                    vp.X         = BitConverter.ToSingle(p.raw, 32);
                    vp.Y         = BitConverter.ToSingle(p.raw, 36);
                    vp.Z         = BitConverter.ToSingle(p.raw, 40);
                    pg           = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, vp, typeof(VectorProp), false, true);
                }
                else if (structType == "Rotator")
                {
                    RotatorProp rp = new RotatorProp();
                    rp.name      = structType;
                    rp.nameindex = p.Value.IntValue;
                    rp.Pitch     = BitConverter.ToInt32(p.raw, 32) * 360f / 65536f;
                    rp.Yaw       = BitConverter.ToInt32(p.raw, 36) * 360f / 65536f;
                    rp.Roll      = BitConverter.ToInt32(p.raw, 40) * 360f / 65536f;
                    pg           = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, rp, typeof(RotatorProp), false, true);
                }
                else if (structType == "LinearColor")
                {
                    LinearColorProp lcp = new LinearColorProp();
                    lcp.name      = structType;
                    lcp.nameindex = p.Value.IntValue;
                    lcp.Red       = BitConverter.ToSingle(p.raw, 32);
                    lcp.Green     = BitConverter.ToSingle(p.raw, 36);
                    lcp.Blue      = BitConverter.ToSingle(p.raw, 40);
                    lcp.Alpha     = BitConverter.ToSingle(p.raw, 44);
                    pg            = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, lcp, typeof(VectorProp), false, true);
                }
                else
                {
                    StructProp ppp = new StructProp();
                    ppp.name      = structType;
                    ppp.nameindex = p.Value.IntValue;
                    byte[] buf = new byte[p.Value.Array.Count()];
                    for (int i = 0; i < p.Value.Array.Count(); i++)
                    {
                        buf[i] = (byte)p.Value.Array[i].IntValue;
                    }
                    List <int> buf2 = new List <int>();
                    for (int i = 0; i < p.Value.Array.Count() / 4; i++)
                    {
                        buf2.Add(BitConverter.ToInt32(buf, i * 4));
                    }
                    ppp.data = buf2.ToArray();
                    pg       = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, ppp, typeof(StructProp), false, true);
                }
                break;

            default:
                pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, p.Value.IntValue, typeof(int), false, true);
                break;
            }
            return(pg);
        }
 public static Property getPropOrNull(UDKFile udk, byte[] data, int start, string propName)
 {
     List<Property> props = ReadProp(udk, data, start);
     foreach (Property prop in props)
     {
         if (udk.getName(prop.Name) == propName)
         {
             return prop;
         }
     }
     return null;
 }
 private static PropertyValue ReadValue(UDKFile udk, byte[] raw, int start, int type)
 {
     PropertyValue v = new PropertyValue();
     switch (udk.getName(type))
     {
         case "IntProperty":
         case "FloatProperty":
         case "ObjectProperty":
         case "StringRefProperty":
             v.IntValue = BitConverter.ToInt32(raw, start);
             v.len = 4;
             break;
         case "NameProperty":
             v.IntValue = BitConverter.ToInt32(raw, start);
             var nameRef = new NameReference();
             nameRef.index = v.IntValue;
             nameRef.count = BitConverter.ToInt32(raw, start + 4);
             nameRef.Name = udk.getName(nameRef.index);
             if (nameRef.count > 0)
                 nameRef.Name += "_" + (nameRef.count - 1);
             v.NameValue = nameRef;
             v.len = 8;
             break;
         case "BoolProperty":
             if(start < raw.Length)
                 v.IntValue = raw[start];
             v.len = 1;
             break;
     }
     return v;
 }
 private void importImport(UDKFile importudk, int n, int link)
 {
     UDKFile.ImportEntry imp = importudk.Imports[n];
     UDKFile.ImportEntry nimp = new UDKFile.ImportEntry(udk, imp.header);
     nimp.idxLink = link;
     nimp.idxClassName = udk.FindNameOrAdd(importudk.getName(imp.idxClassName));
     nimp.idxObjectName = udk.FindNameOrAdd(importudk.getName(imp.idxObjectName));
     nimp.idxPackageFile = udk.FindNameOrAdd(importudk.getName(imp.idxPackageFile));
     udk.addImport(nimp);
 }
Beispiel #32
0
        public static List <Property> ReadProp(UDKFile udk, byte[] raw, int start)
        {
            Property        p;
            PropertyValue   v;
            int             sname;
            List <Property> result = new List <Property>();
            int             pos    = start;

            if (raw.Length - pos < 8)
            {
                return(result);
            }
            int name = (int)BitConverter.ToInt64(raw, pos);

            if (!udk.isName(name))
            {
                return(result);
            }
            string t = udk.getName(name);

            if (udk.getName(name) == "None")
            {
                p           = new Property();
                p.Name      = name;
                p.TypeVal   = Type.None;
                p.i         = 0;
                p.offsetval = pos;
                p.Size      = 8;
                p.Value     = new PropertyValue();
                p.raw       = BitConverter.GetBytes((Int64)name);
                p.offend    = pos + 8;
                result.Add(p);
                return(result);
            }
            int type = (int)BitConverter.ToInt64(raw, pos + 8);
            int size = BitConverter.ToInt32(raw, pos + 16);
            int idx  = BitConverter.ToInt32(raw, pos + 20);

            if (!udk.isName(type) || size < 0 || size >= raw.Length)
            {
                return(result);
            }
            string tp = udk.getName(type);

            switch (tp)
            {
            case "DelegateProperty":
                p           = new Property();
                p.Name      = name;
                p.TypeVal   = Type.DelegateProperty;
                p.i         = 0;
                p.offsetval = pos + 24;
                v           = new PropertyValue();
                v.IntValue  = BitConverter.ToInt32(raw, pos + 28);
                v.len       = size;
                v.Array     = new List <PropertyValue>();
                pos        += 24;
                for (int i = 0; i < size; i++)
                {
                    PropertyValue v2 = new PropertyValue();
                    if (pos < raw.Length)
                    {
                        v2.IntValue = raw[pos];
                    }
                    v.Array.Add(v2);
                    pos++;
                }
                p.Value = v;
                break;

            case "ArrayProperty":
                int count = (int)BitConverter.ToInt64(raw, pos + 24);
                p           = new Property();
                p.Name      = name;
                p.TypeVal   = Type.ArrayProperty;
                p.i         = 0;
                p.offsetval = pos + 24;
                v           = new PropertyValue();
                v.IntValue  = type;
                v.len       = size - 4;
                count       = v.len;//TODO can be other objects too
                v.Array     = new List <PropertyValue>();
                pos        += 28;
                for (int i = 0; i < count; i++)
                {
                    PropertyValue v2 = new PropertyValue();
                    if (pos < raw.Length)
                    {
                        v2.IntValue = raw[pos];
                    }
                    v.Array.Add(v2);
                    pos++;
                }
                p.Value = v;
                break;

            case "StrProperty":
                count       = (int)BitConverter.ToInt64(raw, pos + 24);
                p           = new Property();
                p.Name      = name;
                p.TypeVal   = Type.StrProperty;
                p.i         = 0;
                p.offsetval = pos + 24;
                v           = new PropertyValue();
                v.IntValue  = type;
                v.len       = count;
                pos        += 28;
                string s = "";
                for (int i = 0; i < count; i++)
                {
                    s   += (char)raw[pos];
                    pos += 1;
                }
                v.StringValue = s;
                p.Value       = v;
                break;

            case "StructProperty":
                sname       = (int)BitConverter.ToInt64(raw, pos + 24);
                p           = new Property();
                p.Name      = name;
                p.TypeVal   = Type.StructProperty;
                p.i         = 0;
                p.offsetval = pos + 24;
                v           = new PropertyValue();
                v.IntValue  = sname;
                v.len       = size;
                v.Array     = new List <PropertyValue>();
                pos        += 32;
                for (int i = 0; i < size; i++)
                {
                    PropertyValue v2 = new PropertyValue();
                    if (pos < raw.Length)
                    {
                        v2.IntValue = raw[pos];
                    }
                    v.Array.Add(v2);
                    pos++;
                }
                p.Value = v;
                break;

            case "ByteProperty":
                sname         = (int)BitConverter.ToInt64(raw, pos + 24);
                p             = new Property();
                p.Name        = name;
                p.TypeVal     = Type.ByteProperty;
                p.i           = 0;
                p.offsetval   = pos + 32;
                v             = new PropertyValue();
                v.StringValue = udk.getName(sname);
                v.len         = size;
                pos          += 32;
                if (size == 8)
                {
                    v.IntValue = BitConverter.ToInt32(raw, pos);
                }
                else
                {
                    v.IntValue = raw[pos];
                }
                pos    += size;
                p.Value = v;
                break;

            default:
                p           = new Property();
                p.Name      = name;
                p.TypeVal   = getType(udk, type);
                p.i         = 0;
                p.offsetval = pos + 24;
                p.Value     = ReadValue(udk, raw, pos + 24, type);
                pos        += p.Value.len + 24;
                break;
            }
            p.Size   = size;
            p.raw    = new byte[pos - start];
            p.offend = pos;
            if (pos < raw.Length)
            {
                for (int i = 0; i < pos - start; i++)
                {
                    p.raw[i] = raw[start + i];
                }
            }
            result.Add(p);
            if (pos != start)
            {
                result.AddRange(ReadProp(udk, raw, pos));
            }
            return(result);
        }
        public static ME3LibWV.CustomProperty PropertyToGrid(Property p, UDKFile udk)
        {
            string cat = p.TypeVal.ToString();
            ME3LibWV.CustomProperty pg;
            NameProp pp;
            switch (p.TypeVal)
            {
                case Type.BoolProperty :
                    pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, (p.Value.IntValue == 1), typeof(bool), false, true);
                    break;
                case Type.FloatProperty:
                    byte[] buff = BitConverter.GetBytes(p.Value.IntValue);
                    float f = BitConverter.ToSingle(buff, 0);
                    pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, f, typeof(float), false, true);
                    break;
                case Type.ByteProperty:
                    if (p.Size != 8)
                    {
                        pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, (byte)p.Value.IntValue, typeof(byte), false, true);
                    }
                    else
                    {

                        pp = new NameProp();
                        pp.name = udk.getName(p.Value.IntValue);
                        pp.nameindex = p.Value.IntValue;
                        pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, pp, typeof(NameProp), false, true);
                    }
                    break;
                case Type.NameProperty:
                    pp = new NameProp();
                    pp.name = udk.getName(p.Value.IntValue);
                    pp.nameindex = p.Value.IntValue;
                    pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, pp, typeof(NameProp), false, true);
                    break;
                case Type.ObjectProperty:
                    ObjectProp ppo = new ObjectProp();
                    ppo.objectName = udk.getObjectName(p.Value.IntValue);
                    ppo.index = p.Value.IntValue;
                    pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, ppo, typeof(ObjectProp), false, true);
                    break;
                case Type.StrProperty:
                    pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, p.Value.StringValue, typeof(string), false, true);
                    break;
                case Type.ArrayProperty:
                    pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, BitConverter.ToInt32(p.raw,24) + " elements", typeof(string), false, true);
                    break;
                case Type.StructProperty:
                    string structType = udk.getName(p.Value.IntValue);
                    if(structType == "Color") {
                        ColorProp  cp = new ColorProp();
                        cp.name = structType;
                        cp.nameindex = p.Value.IntValue;
                        System.Drawing.Color color = System.Drawing.Color.FromArgb(BitConverter.ToInt32(p.raw, 32));
                        cp.Alpha = color.A;
                        cp.Red = color.R;
                        cp.Green = color.G;
                        cp.Blue = color.B;
                        pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, cp, typeof(ColorProp), false, true);
                    }
                    else if (structType == "Vector")
                    {
                        VectorProp vp = new VectorProp();
                        vp.name = structType;
                        vp.nameindex = p.Value.IntValue;
                        vp.X = BitConverter.ToSingle(p.raw, 32);
                        vp.Y = BitConverter.ToSingle(p.raw, 36);
                        vp.Z = BitConverter.ToSingle(p.raw, 40);
                        pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, vp, typeof(VectorProp), false, true);
                    }
                    else if (structType == "Rotator")
                    {
                        RotatorProp rp = new RotatorProp();
                        rp.name = structType;
                        rp.nameindex = p.Value.IntValue;
                        rp.Pitch = BitConverter.ToInt32(p.raw, 32) * 360f / 65536f;
                        rp.Yaw = BitConverter.ToInt32(p.raw, 36) * 360f / 65536f;
                        rp.Roll = BitConverter.ToInt32(p.raw, 40) * 360f / 65536f;
                        pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, rp, typeof(RotatorProp), false, true);
                    }
                    else if (structType == "LinearColor")
                    {
                        LinearColorProp lcp = new LinearColorProp();
                        lcp.name = structType;
                        lcp.nameindex = p.Value.IntValue;
                        lcp.Red = BitConverter.ToSingle(p.raw, 32);
                        lcp.Green = BitConverter.ToSingle(p.raw, 36);
                        lcp.Blue = BitConverter.ToSingle(p.raw, 40);
                        lcp.Alpha = BitConverter.ToSingle(p.raw, 44);
                        pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, lcp, typeof(VectorProp), false, true);
                    }
                    else {
                        StructProp ppp = new StructProp();
                        ppp.name = structType;
                        ppp.nameindex = p.Value.IntValue;
                        byte[] buf = new byte[p.Value.Array.Count()];
                        for (int i = 0; i < p.Value.Array.Count(); i++)
                            buf[i] = (byte)p.Value.Array[i].IntValue;
                        List<int> buf2 = new List<int>();
                        for (int i = 0; i < p.Value.Array.Count() / 4; i++)
                            buf2.Add(BitConverter.ToInt32(buf ,i * 4));
                        ppp.data = buf2.ToArray();
                        pg = new ME3LibWV.CustomProperty(udk.getName(p.Name), cat, ppp, typeof(StructProp), false, true);
                    }
                    break;                    
                default:
                    pg = new ME3LibWV.CustomProperty(udk.getName(p.Name),cat,p.Value.IntValue,typeof(int),false,true);
                    break;
            }
            return pg;
        }
        public static void ImportProperty(UDKFile udk, UDKFile importudk, Property p, string className, System.IO.MemoryStream m, bool inStruct = false)
        {
            string name = importudk.getName(p.Name);
            int idxname = udk.FindNameOrAdd(name);
            m.Write(BitConverter.GetBytes(idxname), 0, 4);
            m.Write(new byte[4], 0, 4);
            if (name == "None")
                return;
            string type = importudk.getName(BitConverter.ToInt32(p.raw, 8));
            int idxtype = udk.FindNameOrAdd(type);
            m.Write(BitConverter.GetBytes(idxtype), 0, 4);
            m.Write(new byte[4], 0, 4);
            string name2;
            int idxname2;
            int size, count, pos;
            List<Property> Props;
            switch (type)
            {
                case "IntProperty":
                case "FloatProperty":
                case "ObjectProperty":
                case "NameProperty":
                    m.Write(BitConverter.GetBytes(8), 0, 4);
                    m.Write(new byte[4], 0, 4);
                    m.Write(BitConverter.GetBytes(udk.FindNameOrAdd(importudk.getName(p.Value.IntValue))), 0, 4);
                    //preserve index or whatever the second part of a namereference is
                    m.Write(p.raw, 28, 4);
                    break;
                case "BoolProperty":
                    m.Write(new byte[8], 0, 8);
                    m.WriteByte((byte)p.Value.IntValue);
                    break;
                case "ByteProperty":
                    name2 = importudk.getName(BitConverter.ToInt32(p.raw, 24));
                    idxname2 = udk.FindNameOrAdd(name2);
                    m.Write(BitConverter.GetBytes(p.Size), 0, 4);
                    m.Write(new byte[4], 0, 4);
                    m.Write(BitConverter.GetBytes(idxname2), 0, 4);
                    m.Write(new byte[4], 0, 4);
                    if (p.Size == 8)
                    {
                        m.Write(BitConverter.GetBytes(udk.FindNameOrAdd(importudk.getName(p.Value.IntValue))), 0, 4);
                        m.Write(new byte[4], 0, 4);
                    }
                    else
                    {
                        m.WriteByte(p.raw[32]);
                    }
                    break;
                case "DelegateProperty":
                    size = BitConverter.ToInt32(p.raw, 16);
                    if (size == 0xC)
                    {
                        name2 = importudk.getName(BitConverter.ToInt32(p.raw, 28));
                        idxname2 = udk.FindNameOrAdd(name2);
                        m.Write(BitConverter.GetBytes(0xC), 0, 4);
                        m.Write(new byte[4], 0, 4);
                        m.Write(new byte[4], 0, 4);
                        m.Write(BitConverter.GetBytes(idxname2), 0, 4);
                        m.Write(new byte[4], 0, 4);
                    }
                    else
                    {
                        m.Write(BitConverter.GetBytes(size), 0, 4);
                        m.Write(new byte[4], 0, 4);
                        for (int i = 0; i < size; i++)
                            m.WriteByte(p.raw[24 + i]);
                    }
                    break;
                case "StrProperty":
                    name2 = p.Value.StringValue;
                    m.Write(BitConverter.GetBytes(4 + name2.Length), 0, 4);
                    m.Write(new byte[4], 0, 4);
                    m.Write(BitConverter.GetBytes(name2.Length), 0, 4);
                    foreach (char c in name2)
                    {
                        m.WriteByte((byte)c);
                    }
                    break;
                case "StructProperty":
                    size = BitConverter.ToInt32(p.raw, 16);
                    name2 = importudk.getName(BitConverter.ToInt32(p.raw, 24));
                    idxname2 = udk.FindNameOrAdd(name2);
                    pos = 32;
                    Props = new List<Property>();
                    try
                    {
                        Props = ReadProp(importudk, p.raw, pos);
                    }
                    catch (Exception)
                    {
                    }
                    m.Write(BitConverter.GetBytes(size), 0, 4);
                    m.Write(new byte[4], 0, 4);
                    m.Write(BitConverter.GetBytes(idxname2), 0, 4);
                    m.Write(new byte[4], 0, 4);
                    if (Props.Count == 0 || Props[0].TypeVal == Type.Unknown)
                    {
                        for (int i = 0; i < size; i++)
                            m.WriteByte(p.raw[32 + i]);
                    }
                    else
                    {
                        foreach (Property pp in Props)
                            ImportProperty(udk, importudk, pp, className, m, inStruct);
                    }
                    break;
                case "ArrayProperty":
                    size = BitConverter.ToInt32(p.raw, 16);
                    count = BitConverter.ToInt32(p.raw, 24);
                    PropertyInfo info = getPropertyInfo(className, name, inStruct);
                    ArrayType arrayType = getArrayType(info);
                    pos = 28;
                    List<Property> AllProps = new List<Property>();

                    if (arrayType == ArrayType.Struct)
                    {
                        for (int i = 0; i < count; i++)
                        {
                            Props = new List<Property>();
                            try
                            {
                                Props = ReadProp(importudk, p.raw, pos);
                            }
                            catch (Exception)
                            {
                            }
                            AllProps.AddRange(Props);
                            if (Props.Count != 0)
                            {
                                pos = Props[Props.Count - 1].offend;
                            }
                        }
                    }
                    m.Write(BitConverter.GetBytes(size), 0, 4);
                    m.Write(new byte[4], 0, 4);
                    m.Write(BitConverter.GetBytes(count), 0, 4);
                    if (AllProps.Count != 0 && (info == null || !isImmutable(info.reference)))
                    {
                        foreach (Property pp in AllProps)
                            ImportProperty(udk, importudk, pp, className, m, inStruct);
                    }
                    else if (arrayType == ArrayType.Name)
                    {
                        for (int i = 0; i < count; i++)
                        {
                            string s = importudk.getName(BitConverter.ToInt32(p.raw, 28 + i * 8));
                            m.Write(BitConverter.GetBytes(udk.FindNameOrAdd(s)), 0, 4);
                            //preserve index or whatever the second part of a namereference is
                            m.Write(p.raw, 32 + i * 8, 4);
                        }
                    }
                    else
                    {
                        m.Write(p.raw, 28, size - 4);
                    }
                    break;
                default:
                    throw new Exception(type);
            }
        }