public CSwfTexture(CR2WFile cr2w) : base(cr2w)
{
swfTexture = new CByteArray(cr2w)
{
Name = "swfTexture"
};
}
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[]"
};
}
public CBitmapTexture(CR2WFile cr2w) : base(cr2w)
{
Image = new CByteArray(cr2w)
{
Name = "Image"
};
}
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"
};
}
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"
};
}
public CIndexed2dArray(CR2WFile cr2w) : base(cr2w)
{
arrays = new CByteArray(cr2w)
{
Name = "Serialized data"
};
}
public CGenericGrassMask(CR2WFile cr2w) : base(cr2w)
{
grassmask = new CByteArray(cr2w)
{
Name = "Grass mask data"
};
}
public SMipData(CR2WFile cr2w, CVariable parent, string name) : base(cr2w, parent, name)
{
Mip = new CByteArray(cr2w, this, nameof(Mip))
{
IsSerialized = true
};
}
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);
}
public CCookedExplorations(CR2WFile cr2w) :
base(cr2w)
{
explfile = new CByteArray(cr2w)
{
Name = "explfile"
};
}
public CSwfResource(CR2WFile cr2w) :
base(cr2w)
{
swfResource = new CByteArray(cr2w)
{
Name = "swfResource"
};
unk1 = new CUInt32(cr2w)
{
Name = "unk1"
};
}
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[]"
};
}
public CSwfResource(CR2WFile cr2w) :
base(cr2w)
{
swfResource = new CByteArray(cr2w);
swfResource.Name = "swfResource";
}
/// <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
}
/// <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
}
