Ejemplo n.º 1
0
 public CSwfTexture(CR2WFile cr2w) : base(cr2w)
 {
     swfTexture = new CByteArray(cr2w)
     {
         Name = "swfTexture"
     };
 }
Ejemplo n.º 2
0
 public CSectorData(CR2WFile cr2w)
     : base(cr2w)
 {
     Unknown1 = new CUInt32(cr2w)
     {
         Name = "unknown1",
         Type = "UInt32"
     };
     Unknown2 = new CUInt32(cr2w)
     {
         Name = "unknown2",
         Type = "UInt32"
     };
     Resources = new CVector(cr2w)
     {
         Name = "resources",
         Type = "CSectorDataResource[]"
     };
     Objects = new CVector(cr2w)
     {
         Name = "objects",
         Type = "CSectorDataObject[]"
     };
     BlockData = new CByteArray(cr2w)
     {
         Name = "blockData",
         Type = "byte[]"
     };
 }
Ejemplo n.º 3
0
 public CBitmapTexture(CR2WFile cr2w) : base(cr2w)
 {
     Image = new CByteArray(cr2w)
     {
         Name = "Image"
     };
 }
Ejemplo n.º 4
0
 public CCubeTexture(CR2WFile cr2w) : base(cr2w)
 {
     left = new CByteArray(cr2w)
     {
         Name = "left"
     };
     right = new CByteArray(cr2w)
     {
         Name = "right"
     };
     front = new CByteArray(cr2w)
     {
         Name = "front"
     };
     back = new CByteArray(cr2w)
     {
         Name = "back"
     };
     top = new CByteArray(cr2w)
     {
         Name = "top"
     };
     bottom = new CByteArray(cr2w)
     {
         Name = "bottom"
     };
 }
Ejemplo n.º 5
0
 public CSwarmCellMap(CR2WFile cr2w) : base(cr2w)
 {
     data = new CByteArray(cr2w)
     {
         Name = "Data"
     };
     cornerPosition = new CVector3D(cr2w)
     {
         Name = "Corner position"
     };
     dataSizeX = new CInt32(cr2w)
     {
         Name = "Data size X"
     };
     dataSizeY = new CInt32(cr2w)
     {
         Name = "Data size Y"
     };
     dataSizeZ = new CInt32(cr2w)
     {
         Name = "Data size Z"
     };
     dataSize = new CInt32(cr2w)
     {
         Name = "Data size in bits"
     };
     sizeInKbytes = new CFloat(cr2w)
     {
         Name = "Data size in Kilobytes"
     };
 }
Ejemplo n.º 6
0
 public CIndexed2dArray(CR2WFile cr2w) : base(cr2w)
 {
     arrays = new CByteArray(cr2w)
     {
         Name = "Serialized data"
     };
 }
Ejemplo n.º 7
0
 public CGenericGrassMask(CR2WFile cr2w) : base(cr2w)
 {
     grassmask = new CByteArray(cr2w)
     {
         Name = "Grass mask data"
     };
 }
Ejemplo n.º 8
0
 public SMipData(CR2WFile cr2w, CVariable parent, string name) : base(cr2w, parent, name)
 {
     Mip = new CByteArray(cr2w, this, nameof(Mip))
     {
         IsSerialized = true
     };
 }
Ejemplo n.º 9
0
        public override void Read(BinaryReader file, uint size)
        {
            base.Read(file, size);

            unk.Read(file, 4);
            MipsCount.Read(file, 4);

            // Imported and Cooked xbms have a different file structure.
            // Imported xbms can be identified by their Sourcedata being not null
            var SourceData = this.GetVariableByName("sourceData");

            if (SourceData != null)
            {
                //dbg
                var ResidentMipIndex = this.GetVariableByName("residentMipIndex");
                if (ResidentMipIndex != null)
                {
                    throw new NotImplementedException();
                }

                for (int i = 0; i < MipsCount.val; i++)
                {
                    var mipdata = new SMipData(cr2w);
                    mipdata.Read(file, 16);
                    Mipdata.AddVariable(mipdata);

                    var img = new CByteArray(cr2w);
                    //img.SetParent(this);
                    img.Read(file, 0);
                    Mips.AddVariable(img);
                }
                unk2.Read(file, 4);
            }
            else
            {
                //if (ResidentMipIndex == null)
                //throw new NotImplementedException();


                Mipdata.Read(file, size, (int)MipsCount.val);

                ResidentmipSize.Read(file, 4);

                unk2.Read(file, 4);

                //Residentmip.SetParent(this);
                Residentmip.Read(file, ResidentmipSize.val);
            }

            //if (MipsCount.val > 0)
            //    mips.Read(file, size, (int)MipsCount.val);
            //else
            //    mips.Read(file, size, 1);

            //ResidentmipSize.Read(file, 4);
            //unk2.Read(file, 4);

            //Residentmip.Bytes = file.ReadBytes((int)ResidentmipSize.val);
        }
Ejemplo n.º 10
0
 public CCookedExplorations(CR2WFile cr2w) :
     base(cr2w)
 {
     explfile = new CByteArray(cr2w)
     {
         Name = "explfile"
     };
 }
Ejemplo n.º 11
0
        public CSwfResource(CR2WFile cr2w) :
            base(cr2w)
        {
            swfResource = new CByteArray(cr2w)
            {
                Name = "swfResource"
            };

            unk1 = new CUInt32(cr2w)
            {
                Name = "unk1"
            };
        }
Ejemplo n.º 12
0
 public CSectorDataObject(CR2WFile cr2w)
     : base(cr2w)
 {
     type = new CUInt8(cr2w)
     {
         Name = "type", Type = "UInt8"
     };
     flags = new CUInt8(cr2w)
     {
         Name = "flags", Type = "UInt8"
     };
     radius = new CUInt16(cr2w)
     {
         Name = "radius", Type = "UInt16"
     };
     offset = new CUInt64(cr2w)
     {
         Name = "offset", Type = "UInt64"
     };
     positionX = new CFloat(cr2w)
     {
         Name = "positionX", Type = "Float"
     };
     positionY = new CFloat(cr2w)
     {
         Name = "positionY", Type = "Float"
     };
     positionZ = new CFloat(cr2w)
     {
         Name = "positionZ", Type = "Float"
     };
     blockdata = new CByteArray(cr2w)
     {
         Name = "blockdata", Type = "byte[]"
     };
 }
Ejemplo n.º 13
0
 public CSwfResource(CR2WFile cr2w) :
     base(cr2w)
 {
     swfResource      = new CByteArray(cr2w);
     swfResource.Name = "swfResource";
 }
Ejemplo n.º 14
0
        /// <summary>
        /// The instantiation step of the RedEngine-3 reflection.
        /// </summary>
        /// <param name="typename">Can be either a generic type such as CUint32 - then converted with GetWKitTypeFromREDType, or a complex type like a
        /// pointer to a class, a handle to an import file, an array, a soft reference, a static reference, various buffers, an enum.</param>
        /// <param name="varname">The variable name</param>
        /// <param name="cr2w">The cr2w base file</param>
        /// <param name="parentVariable">The class owning this attribute</param>
        /// <param name="readUnknownAsBytes"></param>
        /// <returns></returns>
        public static CVariable Create(string typename, string varname, CR2WFile cr2w, CVariable parentVariable, bool readUnknownAsBytes = true)
        {
            typename = REDReflection.GetWKitBaseTypeFromREDBaseType(typename);
            var fullname = typename;

            // check for normal type
            if (AssemblyDictionary.TypeExists(typename))
            {
                var type = AssemblyDictionary.GetTypeByName(typename);
                if (type != null)
                {
                    object instance = Activator.CreateInstance(type, cr2w, parentVariable, varname);
                    return(instance as CVariable);
                }
            }

            // check for enum types
            if (AssemblyDictionary.EnumExists(typename))
            {
                Enum e     = (Enum)Activator.CreateInstance(AssemblyDictionary.GetEnumByName(typename));
                var  cenum = MakeGenericEnumType(typeof(CEnum <>), e);
                return(cenum);
            }
            else if (CR2WManager.EnumExists(typename))
            {
                Enum e     = (Enum)Activator.CreateInstance(CR2WManager.GetEnumByName(typename));
                var  cenum = MakeGenericEnumType(typeof(CEnum <>), e);
                return(cenum);
            }
            // check for generic type
            else if (typename.Contains(':'))
            {
                #region GENERIC TYPES
                string[] splits      = typename.Split(':');
                string   generictype = splits.First();
                string   innertype   = string.Join(":", splits.Skip(1));
                // e.g. handle:CEntityTemplate
                switch (generictype)
                {
                case "CHandle":
                case "handle":
                {
                    CVariable innerobject = Create(innertype, "", cr2w, null);
                    return(MakeGenericType(typeof(CHandle <>), innerobject));
                }

                case "CPtr":
                case "ptr":
                {
                    CVariable innerobject = Create(innertype, "", cr2w, null);
                    return(MakeGenericType(typeof(CPtr <>), innerobject));
                }

                case "CSoft":
                case "soft":
                {
                    CVariable innerobject = Create(innertype, "", cr2w, null);
                    return(MakeGenericType(typeof(CSoft <>), innerobject));
                }

                case "array":
                {
                    // match pattern e.g.
                    // array:            Array: (2),(0),(handle:CBitmapTexture)
                    // array:            Array: (2),(0),(Int32)
                    // array of array:   Array: (2),(0),(Array:133,0,EngineQsTransform)

                    string[] arraysplits = innertype.Split(',');
                    string   flag1       = arraysplits[0];
                    string   flag2       = arraysplits[1];
                    string   body        = string.Join(",", arraysplits.Skip(2));
                    if (arraysplits.Length >= 3)
                    {
                        //byte arrays, these can be huge, using ordinary arrays is just too slow.
                        if (body == "Uint8" || body == "Int8")
                        {
                            var bytearray = new CByteArray(cr2w, parentVariable, varname);
                            // save the actual redengine type for serialization: e.g. array:2,0,Uint8
                            bytearray.InternalType = typename;
                            return(bytearray);
                        }

                        // all other arrays
                        CVariable      innerobject = Create(body, "", cr2w, null);
                        IArrayAccessor arrayacc    = MakeArray(typeof(CArray <>), innerobject.GetType());
                        arrayacc.Flags = new List <int>()
                        {
                            int.Parse(flag1), int.Parse(flag2)
                        };
                        if (innerobject is IArrayAccessor accessor && accessor.Flags != null)
                        {
                            arrayacc.Flags.AddRange(accessor.Flags);
                        }
                        arrayacc.Elementtype = body;
                        return(arrayacc as CVariable);
                    }
                    else
                    {
                        CVariable      innerobject = Create(innertype, "", cr2w, null);
                        IArrayAccessor arrayacc    = MakeArray(typeof(CArray <>), innerobject.GetType());
                        arrayacc.Elementtype = body;
                        return(arrayacc as CVariable);
                    }
                }

                case "static":
                {
                    typename = generictype;

                    // match pattern e.g.
                    // static:  (4),(Uint32)
                    var regArrayType   = new Regex(@"(\d+),(.+)");
                    var matchArrayType = regArrayType.Match(fullname);
                    if (matchArrayType.Success)
                    {
                        CVariable innerobject = Create(matchArrayType.Groups[2].Value, "", cr2w, null);
                        var       arrayacc    = MakeArray(typeof(CStatic <>), innerobject.GetType());
                        arrayacc.Flags = new List <int>()
                        {
                            int.Parse(matchArrayType.Groups[1].Value)
                        };
                        arrayacc.Elementtype = matchArrayType.Groups[2].Value;
                        return(arrayacc as CVariable);
                    }
                    else
                    {
                        throw new InvalidParsingException($"Invalid static type format: typename: {typename}.");
                    }
                }

                case "CBufferUInt16":
                {
                    CVariable innerobject = Create(innertype, "", cr2w, null);
                    return(MakeGenericType(typeof(CBufferUInt16 <>), innerobject));
                }

                case "CBufferUInt32":
                {
                    CVariable innerobject = Create(innertype, "", cr2w, null);
                    return(MakeGenericType(typeof(CBufferUInt32 <>), innerobject));
                }

                case "CBufferVLQInt32":
                {
                    CVariable innerobject = Create(innertype, "", cr2w, null);
                    return(MakeGenericType(typeof(CBufferVLQInt32 <>), innerobject));
                }

                case "CCompressedBuffer":
                {
                    CVariable innerobject = Create(innertype, "", cr2w, null);
                    return(MakeGenericType(typeof(CCompressedBuffer <>), innerobject));
                }

                case "CPaddedBuffer":
                {
                    CVariable innerobject = Create(innertype, "", cr2w, null);
                    return(MakeGenericType(typeof(CPaddedBuffer <>), innerobject));
                }

                case "CEnum":
                {
                    Enum innerobject = CreateEnum(innertype);
                    return(MakeGenericEnumType(typeof(CEnum <>), innerobject));
                }

                default:
                {
                    throw new NotImplementedException();
                }
                }
                #endregion
            }
            else
            {
                #region FIXED SIZE ARRAYS
                // match pattern e.g.
                // [(1)](Bezier2dHandle)
                var regFixedSizeArray   = new Regex(@"^\[(\d+)\](.+)$");
                var matchFixedSizeArray = regFixedSizeArray.Match(typename);
                if (matchFixedSizeArray.Success)
                {
                    CVariable innerobject = Create(matchFixedSizeArray.Groups[2].Value, "", cr2w, null);
                    var       arrayacc    = MakeArray(typeof(CArrayFixedSize <>), innerobject.GetType());
                    arrayacc.Flags = new List <int>()
                    {
                        int.Parse(matchFixedSizeArray.Groups[1].Value)
                    };
                    arrayacc.Elementtype = matchFixedSizeArray.Groups[2].Value;
                    return(arrayacc as CVariable);
                }
                #endregion

                if (fullname.Contains("@SItem"))
                {
                    cr2w.UnknownTypes.Add($"Congratulations! You have found one of the hidden e3 files! These files are special." +
                                          $" If you edited this file and are experiencing errors, please contact a member of the Wkit Team. ErrorCode: {fullname}");
                    return(new SItem(cr2w, parentVariable, varname));
                }
                else if (fullname.Contains("#CEnvironmentDefinition"))
                {
                    cr2w.UnknownTypes.Add($"Congratulations! You have found one of the hidden e3 files! These files are special." +
                                          $" If you edited this file and are experiencing errors, please contact a member of the Wkit Team. ErrorCode: {fullname}");
                    return(new CHandle <CEnvironmentDefinition>(cr2w, parentVariable, varname));
                }
                else
                {
                    // check if custom type
                    if (CR2WManager.TypeExists(typename))
                    {
                        var    type     = CR2WManager.GetTypeByName(typename);
                        object instance = Activator.CreateInstance(type, cr2w, parentVariable, varname);
                        return(instance as CVariable);
                    }


                    // this should never happen

                    if (!cr2w.UnknownTypes.Contains(fullname))
                    {
                        cr2w.UnknownTypes.Add(fullname);
                    }

                    if (readUnknownAsBytes)
                    {
                        return(new CBytes(cr2w, parentVariable, $"UNKNOWN:{typename}:{varname}"));
                    }
                    else
                    {
                        return(null);
                    }
                }
            }


            #region LOCAL FUNCTIONS


            IArrayAccessor MakeArray(Type arraytype, Type generictype)
            {
                Type elementType;

                if (arraytype == typeof(CStatic <>))
                {
                    elementType = typeof(CStatic <>).MakeGenericType(generictype);
                }
                else if (arraytype == typeof(CArrayFixedSize <>))
                {
                    elementType = typeof(CArrayFixedSize <>).MakeGenericType(generictype);
                }
                else if (arraytype == typeof(CArray <>))
                {
                    elementType = typeof(CArray <>).MakeGenericType(generictype);
                }
                else
                {
                    throw new NotImplementedException();
                }


                var array = Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;

                return(array as IArrayAccessor);
            }

            CVariable MakeGenericType(Type gentype, CVariable innerobject)
            {
                if (innerobject != null)
                {
                    Type      elementType = gentype.MakeGenericType(innerobject.GetType());
                    CVariable handle      = Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
                    return(handle);
                }
                else
                {
                    throw new Exception();
                }
            }

            CVariable MakeGenericEnumType(Type gentype, Enum innerobject)
            {
                if (innerobject != null)
                {
                    Type      elementType = gentype.MakeGenericType(innerobject.GetType());
                    CVariable handle      = Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
                    return(handle);
                }
                else
                {
                    throw new Exception();
                }
            }

            #endregion
        }
Ejemplo n.º 15
0
        /// <summary>
        /// The instantiation step of the RedEngine-3 reflection.
        /// </summary>
        /// <param name="typename">Can be either a generic type such as CUint32 - then converted with GetWKitTypeFromREDType, or a complex type like a
        /// pointer to a class, a handle to an import file, an array, a soft reference, a static reference, various buffers, an enum.</param>
        /// <param name="varname">The variable name</param>
        /// <param name="cr2w">The cr2w base file</param>
        /// <param name="parentVariable">The class owning this attribute</param>
        /// <param name="readUnknownAsBytes"></param>
        /// <returns></returns>
        public static CVariable Create(string typename, string varname, CR2WFile cr2w, CVariable parentVariable, bool readUnknownAsBytes = true)
        {
            typename = REDReflection.GetWKitBaseTypeFromREDBaseType(typename);

            // first try to create instance of type
            #region W3 TYPES
            try
            {
                var type = Type.GetType($"WolvenKit.CR2W.Types.{typename}", false, false);
                // if succesful return as CVariable
                if (type != null)
                {
                    //var instance = type.GetMethod("Create").Invoke(type, new object[]{ cr2w, parentVariable, varname });

                    object instance = Activator.CreateInstance(type, cr2w, parentVariable, varname);
                    return(instance as CVariable);
                }
            }
            catch (System.IO.FileLoadException)
            {
            }
            #endregion

            var fullname = typename;
            // check for enum
            if (typeof(Enums).GetNestedTypes().Select(_ => _.Name).Contains(typename))
            {
                Enum e = (Enum)Activator.CreateInstance(typeof(Enums).GetNestedTypes().FirstOrDefault(_ => _.Name == typename));

                //if (e.GetType().IsDefined(typeof(FlagsAttribute), false))
                //{
                //    typename = REDReflection.GetWKitTypeFromREDType(typename);
                //    var etype = Type.GetType($"WolvenKit.CR2W.Types.{typename}");
                //    object einstance = Activator.CreateInstance(etype, cr2w, parentVariable, varname);
                //    return einstance as CVariable;
                //}

                var cenum = MakeGenericEnumType(typeof(CEnum <>), e);
                return(cenum);
            }
            // finally, check for generic type
            else if (typename.Contains(':'))
            {
                //try
                //{
                #region GENERIC TYPES
                // match pattern e.g.
                // (handle):(CGenericGrassMask) or
                // (array):(2,0,handle:CBitmapTexture)
                var reg   = new Regex(@"^(\w+):(.+)$");
                var match = reg.Match(typename);
                if (match.Success)
                {
                    switch (match.Groups[1].Value)
                    {
                    case "CHandle":
                    case "handle":
                    {
                        CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
                        return(MakeGenericType(typeof(CHandle <>), innerobject));
                    }

                    case "CPtr":
                    case "ptr":
                    {
                        CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
                        return(MakeGenericType(typeof(CPtr <>), innerobject));
                    }

                    case "CSoft":
                    case "soft":
                    {
                        CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
                        return(MakeGenericType(typeof(CSoft <>), innerobject));
                    }

                    case "array":
                    {
                        typename = match.Groups[1].Value;

                        // match pattern e.g.
                        // array:            Array: (2),(0),(handle:CBitmapTexture)
                        // array:            Array: (2),(0),(Int32)
                        // array of array:   Array: (2),(0),(Array:133,0,EngineQsTransform)
                        var regArrayType   = new Regex(@"(\d+),(\d+),(.+)");
                        var matchArrayType = regArrayType.Match(fullname);
                        if (matchArrayType.Success)
                        {
                            //byte arrays, these can be huge, using ordinary arrays is just too slow.
                            if (matchArrayType.Groups[3].Value == "Uint8" || matchArrayType.Groups[3].Value == "Int8")
                            {
                                var bytearray = new CByteArray(cr2w, parentVariable, varname);
                                bytearray.InternalType = fullname;
                                return(bytearray);
                            }



                            CVariable      innerobject = Create(matchArrayType.Groups[3].Value, "", cr2w, null);
                            IArrayAccessor arrayacc    = MakeArray(typeof(CArray <>), innerobject.GetType());
                            arrayacc.Flags = new List <int>()
                            {
                                int.Parse(matchArrayType.Groups[1].Value), int.Parse(matchArrayType.Groups[2].Value)
                            };
                            if (innerobject is IArrayAccessor accessor && accessor.Flags != null)
                            {
                                arrayacc.Flags.AddRange(accessor.Flags);
                            }


                            arrayacc.Elementtype = matchArrayType.Groups[3].Value;

                            return(arrayacc as CVariable);
                        }
                        // for CArrays of other types
                        else
                        {
                            //throw new InvalidParsingException($"Invalid array type format: typename: {typename}.");
                            CVariable      innerobject = Create(match.Groups[2].Value, "", cr2w, null);
                            IArrayAccessor arrayacc    = MakeArray(typeof(CArray <>), innerobject.GetType());
                            arrayacc.Elementtype = matchArrayType.Groups[3].Value;
                            return(arrayacc as CVariable);
                        }
                    }

                    case "static":
                    {
                        typename = match.Groups[1].Value;

                        // match pattern e.g.
                        // static:  (4),(Uint32)
                        var regArrayType   = new Regex(@"(\d+),(.+)");
                        var matchArrayType = regArrayType.Match(fullname);
                        if (matchArrayType.Success)
                        {
                            CVariable innerobject = Create(matchArrayType.Groups[2].Value, "", cr2w, null);
                            var       arrayacc    = MakeArray(typeof(CStatic <>), innerobject.GetType());
                            arrayacc.Flags = new List <int>()
                            {
                                int.Parse(matchArrayType.Groups[1].Value)
                            };
                            arrayacc.Elementtype = matchArrayType.Groups[2].Value;
                            return(arrayacc as CVariable);
                        }
                        else
                        {
                            throw new InvalidParsingException($"Invalid static type format: typename: {typename}.");
                        }
                    }

                    case "CBufferUInt16":
                    {
                        CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
                        return(MakeGenericType(typeof(CBufferUInt16 <>), innerobject));
                    }

                    case "CBufferUInt32":
                    {
                        CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
                        return(MakeGenericType(typeof(CBufferUInt32 <>), innerobject));
                    }

                    case "CBufferVLQInt32":
                    {
                        CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
                        return(MakeGenericType(typeof(CBufferVLQInt32 <>), innerobject));
                    }

                    case "CCompressedBuffer":
                    {
                        CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
                        return(MakeGenericType(typeof(CCompressedBuffer <>), innerobject));
                    }

                    case "CPaddedBuffer":
                    {
                        CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
                        return(MakeGenericType(typeof(CPaddedBuffer <>), innerobject));
                    }

                    case "CEnum":
                    {
                        Enum innerobject = CreateEnum(match.Groups[2].Value);
                        return(MakeGenericEnumType(typeof(CEnum <>), innerobject));
                    }

                    default:
                    {
                        typename = match.Groups[1].Value;

                        throw new NotImplementedException();

                        break;
                    }
                    }
                }
                else
                {
                    throw new NotImplementedException();
                }
                #endregion
                //}
                //catch (Exception ex)
                //{
                //    throw ex;
                //}
            }
            else
            {
                #region FIXED SIZE ARRAYS
                // match pattern e.g.
                // [(1)](Bezier2dHandle)
                var regFixedSizeArray   = new Regex(@"^\[(\d+)\](.+)$");
                var matchFixedSizeArray = regFixedSizeArray.Match(typename);
                if (matchFixedSizeArray.Success)
                {
                    CVariable innerobject = Create(matchFixedSizeArray.Groups[2].Value, "", cr2w, null);
                    var       arrayacc    = MakeArray(typeof(CArrayFixedSize <>), innerobject.GetType());
                    arrayacc.Flags = new List <int>()
                    {
                        int.Parse(matchFixedSizeArray.Groups[1].Value)
                    };
                    arrayacc.Elementtype = matchFixedSizeArray.Groups[2].Value;
                    return(arrayacc as CVariable);
                }
                #endregion

                if (fullname.Contains("@SItem"))
                {
                    cr2w.UnknownTypes.Add($"Congratulations! You have found one of the hidden e3 files! These files are special." +
                                          $" If you edited this file and are experiencing errors, please contact a member of the Wkit Team. ErrorCode: {fullname}");
                    return(new SItem(cr2w, parentVariable, varname));
                }
                else if (fullname.Contains("#CEnvironmentDefinition"))
                {
                    cr2w.UnknownTypes.Add($"Congratulations! You have found one of the hidden e3 files! These files are special." +
                                          $" If you edited this file and are experiencing errors, please contact a member of the Wkit Team. ErrorCode: {fullname}");
                    return(new CHandle <CEnvironmentDefinition>(cr2w, parentVariable, varname));
                }
                else
                {
                    if (!cr2w.UnknownTypes.Contains(fullname))
                    {
                        cr2w.UnknownTypes.Add(fullname);
                    }

                    // this should never happen

                    if (readUnknownAsBytes)
                    {
                        return(new CBytes(cr2w, parentVariable, "unknownBytes"));
                    }
                    else
                    {
                        return(null);
                    }
                }
            }


            #region LOCAL FUNCTIONS


            IArrayAccessor MakeArray(Type arraytype, Type generictype)
            {
                Type elementType = typeof(CArray <>);

                if (arraytype == typeof(CStatic <>))
                {
                    elementType = typeof(CStatic <>).MakeGenericType(generictype);
                }
                else if (arraytype == typeof(CArrayFixedSize <>))
                {
                    elementType = typeof(CArrayFixedSize <>).MakeGenericType(generictype);
                }
                else if (arraytype == typeof(CArray <>))
                {
                    elementType = typeof(CArray <>).MakeGenericType(generictype);
                }
                else
                {
                    throw new NotImplementedException();
                }


                var array = Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;

                return(array as IArrayAccessor);
            }

            CVariable MakeGenericType(Type gentype, CVariable innerobject)
            {
                if (innerobject != null)
                {
                    Type      elementType = gentype.MakeGenericType(innerobject.GetType());
                    CVariable handle      = Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
                    return(handle);
                }
                else
                {
                    throw new Exception();
                }
            }

            CVariable MakeGenericEnumType(Type gentype, Enum innerobject)
            {
                if (innerobject != null)
                {
                    Type      elementType = gentype.MakeGenericType(innerobject.GetType());
                    CVariable handle      = Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
                    return(handle);
                }
                else
                {
                    throw new Exception();
                }
            }

            #endregion
        }