public void PostInit(UnrealPackage package)
{
Package = package;
if (!CanRead)
{
return;
}
if (package.Decoder != null)
{
package.Decoder.PreDecode(this);
}
var bytes = new byte[4];
Read(bytes, 0, 4);
var readSignature = BitConverter.ToUInt32(bytes, 0);
if (readSignature == UnrealPackage.Signature_BigEndian)
{
Console.WriteLine("Encoding:BigEndian");
BigEndianCode = true;
}
if (!UnrealConfig.SuppressSignature &&
readSignature != UnrealPackage.Signature &&
readSignature != UnrealPackage.Signature_BigEndian)
{
throw new FileLoadException(package.PackageName + " isn't an UnrealPackage!");
}
Position = 4;
}
/// <summary>
/// Loads the given file specified by PackagePath and
/// returns the serialized UnrealPackage.
/// </summary>
public static UnrealPackage LoadPackage(string packagePath, FileAccess fileAccess = FileAccess.Read)
{
var packageName = Path.GetFileNameWithoutExtension(packagePath);
UPackageStream stream;
if (packageName.EndsWith("_decrypted"))
{
stream = new UPackageStream(packagePath, FileMode.Open, fileAccess);
Log.Info("Loading decrypted RL package");
}
else
{
try
{
stream = new RLPackageStream(packagePath);
Log.Info("Loading encrypted RL package");
}
catch (InvalidDataException e)
{
stream = new UPackageStream(packagePath, FileMode.Open, fileAccess);
stream.Position = 0;
}
}
var package = new UnrealPackage(stream);
package.Deserialize(stream);
return(package);
}
public void PostInit(UnrealPackage package)
{
Package = package;
if (!_stream.CanRead)
{
return;
}
if (package.Decoder != null)
{
package.Decoder.PreDecode(this);
}
var bytes = new byte[4];
Read(bytes, 0, 4);
var readSignature = BitConverter.ToUInt32(bytes, 0);
if (readSignature == UnrealPackage.Signature_BigEndian)
{
Log.Info("Encoding:BigEndian");
BigEndianCode = true;
}
if (!UnrealConfig.SuppressSignature &&
readSignature != UnrealPackage.Signature &&
readSignature != UnrealPackage.Signature_BigEndian)
{
throw new FileLoadException($"{package.PackageName} isn't an UnrealPackage! with signature {readSignature}");
}
_stream.Position = 4;
}
private static void CacheExportClasses(UnrealPackage package)
{
foreach (var obj in package.Objects)
{
if (obj.ExportTable == null || obj.Name == "None")
{
//Skip classes that are not defined in this package. And None classes(Wtf even is that..)
continue;
}
if (obj.IsClassType("Class") || obj.IsClassType("ScriptStruct"))
{
if (_LoadedClasses.ContainsKey(obj.Name))
{
_LoadedClasses[obj.Name] = (UStruct)obj;
Log.Debug(
$"{obj.Name} already in class cache. Overwriting with class from {package.FullPackageName} (What could go wrong right?");
}
else
{
_LoadedClasses.Add(obj.Name, (UStruct)obj);
}
}
}
}
/// <summary>
/// Loads the package that this object instance resides in.
///
/// Note: The package closes when the Owner is done with importing objects data.
/// </summary>
protected UnrealPackage LoadImportPackage()
{
UnrealPackage pkg = null;
try
{
var outer = Outer;
while (outer != null)
{
if (outer.Outer == null)
{
pkg = UnrealLoader.LoadCachedPackage(Path.GetDirectoryName(Package.FullPackageName) + "\\" + outer.Name + ".u");
break;
}
outer = outer.Outer;
}
}
catch (IOException)
{
if (pkg != null)
{
pkg.Dispose();
}
return(null);
}
return(pkg);
}
/// <summary>
/// Loads the given file specified by PackagePath and
/// returns the serialized UnrealPackage.
/// </summary>
public static UnrealPackage LoadPackage(string packagePath, FileAccess fileAccess = FileAccess.Read)
{
var stream = new UPackageStream(packagePath, FileMode.Open, fileAccess);
var package = new UnrealPackage(stream);
package.Deserialize(stream);
return(package);
}
public static void AddNamesToNameTable(UnrealPackage package)
{
var namesToAdd = new List <string>()
{
"SizeX", "IntProperty", "None"
};
AddNamesToNameTable(package, namesToAdd);
}
public UObject FindObject(string fullname, Type type)
{
string[] words = fullname.Split('.');
UnrealPackage p = LoadPackage(words[0]);
p.InitializePackage();
words = words.RemoveAt(0);
return(p.FindObject(String.Join(".", words), type));
}
public override void Write(IUnrealStream stream, UnrealPackage package)
{
FixNameIndexAtPosition(package, "SizeX", 4);
FixNameIndexAtPosition(package, "IntProperty", 12);
FixNameIndexAtPosition(package, "None", 32);
stream.Write(minimalByteArray, 0, serialSize - 4);
stream.Write((int)stream.Position + sizeof(int));
}
public static void AddNamesToNameTable(UnrealPackage package)
{
var namesToAdd = new List <string>()
{
"StaticMesh", "SourceFileTimestamp", "StrProperty", "SourceFilePath",
"LightMapCoordinateIndex", "IntProperty", "LightMapResolution", "None",
};
AddNamesToNameTable(package, namesToAdd);
}
protected void FixNameIndexAtPosition(UnrealPackage package, string name, int startPosition)
{
var test = package.Names.FindIndex((n) => n.Name == name);
var bytes = BitConverter.GetBytes(test);
for (int i = 0; i < bytes.Length; i++)
{
minimalByteArray[i + startPosition] = bytes[i];
}
}
private void PreInit(UnrealPackage package)
{
UnrealConfig.VariableTypes = new System.Collections.Generic.Dictionary <string, Tuple <string, PropertyType> >();
foreach (string current in VariableTypes)
{
Tuple <string, string, UELib.Types.PropertyType> tuple = ParseVariable(current);
UnrealConfig.VariableTypes.Add(tuple.Item1, Tuple.Create <string, PropertyType>(tuple.Item2, tuple.Item3));
}
package.RegisterClass("StaticMesh", typeof(UStaticMesh));
package.RegisterClass("Shader", typeof(UShader));
}
//public uint Version { get; set; }
public RLDummyPackageStream(UnrealPackage package, string filePath)
{
this.package = package;
var fileStream = File.Open(filePath, FileMode.Create, FileAccess.Write);
_stream = fileStream;
Package = package;
UW = new RLPackageWriter(_stream, DummyEngineVersion);
MinimalTexture2D.AddNamesToNameTable(package);
}
protected static void AddNamesToNameTable(UnrealPackage package, IList <string> namesToAdd)
{
foreach (var name in namesToAdd)
{
if (!package.Names.Any((o) => o.Name == name))
{
package.Names.Add(new UNameTableItem()
{
Name = name, Flags = 1970393556451328
});
}
}
}
public static void AddNamesToNameTable(UnrealPackage package)
{
var namesToAdd = new List <string>()
{
"SizeX", "IntProperty", "SizeY", "OriginalSizeX",
"OriginalSizeY", "Format", "ByteProperty", "EPixelFormat",
"PF_A8R8G8B8", "bIsSourceArtUncompressed", "BoolProperty", "CompressionNone",
"MipGenSettings", "TextureMipGenSettings", "TMGS_NoMipmaps",
"LightingGuid", "StructProperty", "Guid", "None"
};
AddNamesToNameTable(package, namesToAdd);
}
public Package(string packageName, Vector2 kismetLoc, UnrealPackage unrealPackage)
{
Name = packageName;
KismetLoc = kismetLoc;
var materials = unrealPackage.Objects.Where(obj => obj.ExportTable != null && obj.Name != "None" &&
(obj.GetClassName() == "Material" || obj.GetClassName() == "MaterialInstanceConstant")).ToList();
foreach (var material in materials)
{
Materials.Add($"{material.GetClassName()}'{Name}.{material.GetOuterGroup()}'");
}
}
public static void AddNamesToNameTable(UnrealPackage package)
{
var namesToAdd = new List <string>()
{
"ClothingAssets", "ArrayProperty", "LODInfo", "SourceFilePath",
"StrProperty", "SourceFileTimestamp", "DisplayFactor", "FloatProperty",
"LODHysteresis", "LODMaterialMap", "bEnableShadowCasting", "TriangleSortSettings",
"TriangleSorting", "ByteProperty", "TriangleSortOption", "TRISORT_None", "CustomLeftRightAxis",
"TriangleSortAxis", "TSA_X_Axis", "CustomLeftRightBoneName", "NameProperty",
"bDisableCompressions", "BoolProperty", "bHasBeenSimplified",
};
AddNamesToNameTable(package, namesToAdd);
}
/// <summary>
/// Loads the given file specified by PackagePath and
/// returns the serialized UnrealPackage.
/// </summary>
public static UnrealPackage LoadPackage(string packagePath, FileAccess fileAccess = FileAccess.Read)
{
var packageName = Path.GetFileNameWithoutExtension(packagePath);
UPackageStream stream;
if (packageName.EndsWith("_decrypted"))
{
stream = new UPackageStream(packagePath, FileMode.Open, fileAccess);
Log.Info("Loading decrypted RL package");
}
else
{
try
{
var rlStream = new RLPackageStream(packagePath);
if (rlStream.decryptionState == RLUPKT.Core.DecryptionState.Success)
{
stream = rlStream;
}
else
{
return(null);
}
Log.Info("Loading encrypted RL package");
}
catch (InvalidDataException e)
{
stream = new UPackageStream(packagePath, FileMode.Open, fileAccess)
{
Position = 0
};
}
}
var package = new UnrealPackage(stream);
package.Deserialize(stream);
FullyLoadImportPackages(package, Path.GetDirectoryName(packagePath));
Log.Info($"[LoadPackage] done Loading {packageName}");
return(package);
}
public void Write(IUnrealStream stream, UnrealPackage package)
{
FixNameIndexAtPosition(package, "SizeX", 4);
FixNameIndexAtPosition(package, "IntProperty", 12);
FixNameIndexAtPosition(package, "SizeY", 32);
FixNameIndexAtPosition(package, "IntProperty", 40);
FixNameIndexAtPosition(package, "OriginalSizeX", 60);
FixNameIndexAtPosition(package, "IntProperty", 68);
FixNameIndexAtPosition(package, "OriginalSizeY", 88);
FixNameIndexAtPosition(package, "IntProperty", 96);
FixNameIndexAtPosition(package, "OriginalSizeX", 60);
FixNameIndexAtPosition(package, "IntProperty", 68);
FixNameIndexAtPosition(package, "Format", 116);
FixNameIndexAtPosition(package, "ByteProperty", 124);
FixNameIndexAtPosition(package, "EPixelFormat", 140);
FixNameIndexAtPosition(package, "PF_A8R8G8B8", 148);
FixNameIndexAtPosition(package, "bIsSourceArtUncompressed", 156);
FixNameIndexAtPosition(package, "BoolProperty", 164);
FixNameIndexAtPosition(package, "CompressionNone", 181);
FixNameIndexAtPosition(package, "BoolProperty", 189);
FixNameIndexAtPosition(package, "MipGenSettings", 206);
FixNameIndexAtPosition(package, "ByteProperty", 214);
FixNameIndexAtPosition(package, "TextureMipGenSettings", 230);
FixNameIndexAtPosition(package, "TMGS_NoMipmaps", 238);
FixNameIndexAtPosition(package, "LightingGuid", 246);
FixNameIndexAtPosition(package, "StructProperty", 254);
FixNameIndexAtPosition(package, "Guid", 270);
FixNameIndexAtPosition(package, "None", 294);
stream.Write(minimalTex2D, 0, serialSize);
}
//public uint Version { get; set; }
public RLDummyPackageStream(UnrealPackage package, string filePath)
{
this.package = package;
var fileStream = File.Open(filePath, FileMode.Create, FileAccess.Write);
_stream = fileStream;
Package = package;
UW = new RLPackageWriter(_stream, DummyEngineVersion);
//Could this be done by the factory?
Texture2D.AddNamesToNameTable(package);
StaticMesh.AddNamesToNameTable(package);
TextureRenderTarget2D.AddNamesToNameTable(package);
TextureRenderTargetCube.AddNamesToNameTable(package);
SkeletalMesh.AddNamesToNameTable(package);
//Init the factory
dummyFactory = DummyFactory.Instance;
}
public override void Write(IUnrealStream stream, UnrealPackage package)
{
FixNameIndexAtPosition(package, "ClothingAssets", 4);
FixNameIndexAtPosition(package, "ArrayProperty", 12);
FixNameIndexAtPosition(package, "LODInfo", 36);
FixNameIndexAtPosition(package, "ArrayProperty", 44);
FixNameIndexAtPosition(package, "DisplayFactor", 64);
FixNameIndexAtPosition(package, "FloatProperty", 72);
FixNameIndexAtPosition(package, "LODHysteresis", 92);
FixNameIndexAtPosition(package, "FloatProperty", 100);
FixNameIndexAtPosition(package, "LODMaterialMap", 120);
FixNameIndexAtPosition(package, "ArrayProperty", 128);
FixNameIndexAtPosition(package, "bEnableShadowCasting", 148);
FixNameIndexAtPosition(package, "ArrayProperty", 156);
FixNameIndexAtPosition(package, "TriangleSortSettings", 177);
FixNameIndexAtPosition(package, "ArrayProperty", 185);
FixNameIndexAtPosition(package, "TriangleSorting", 205);
FixNameIndexAtPosition(package, "ByteProperty", 213);
FixNameIndexAtPosition(package, "TriangleSortOption", 229);
FixNameIndexAtPosition(package, "TRISORT_None", 237);
FixNameIndexAtPosition(package, "CustomLeftRightAxis", 245);
FixNameIndexAtPosition(package, "ByteProperty", 253);
FixNameIndexAtPosition(package, "TriangleSortAxis", 269);
FixNameIndexAtPosition(package, "TSA_X_Axis", 277);
FixNameIndexAtPosition(package, "CustomLeftRightBoneName", 285);
FixNameIndexAtPosition(package, "NameProperty", 293);
FixNameIndexAtPosition(package, "None", 309);
FixNameIndexAtPosition(package, "None", 317);
FixNameIndexAtPosition(package, "bDisableCompressions", 325);
FixNameIndexAtPosition(package, "BoolProperty", 333);
FixNameIndexAtPosition(package, "bHasBeenSimplified", 350);
FixNameIndexAtPosition(package, "BoolProperty", 358);
FixNameIndexAtPosition(package, "None", 375);
FixNameIndexAtPosition(package, "SourceFilePath", 383);
FixNameIndexAtPosition(package, "StrProperty", 391);
FixNameIndexAtPosition(package, "SourceFileTimestamp", 472);
FixNameIndexAtPosition(package, "StrProperty", 480);
FixNameIndexAtPosition(package, "None", 520);
stream.Write(minimalByteArray, 0, serialSize);
}
public override void Write(IUnrealStream stream, UnrealPackage package)
{
//FixNameIndexAtPosition(package, "StaticMesh", 0);
FixNameIndexAtPosition(package, "SourceFileTimestamp", 4);
FixNameIndexAtPosition(package, "StrProperty", 12);
FixNameIndexAtPosition(package, "SourceFilePath", 52);
FixNameIndexAtPosition(package, "StrProperty", 60);
FixNameIndexAtPosition(package, "LightMapCoordinateIndex", 86);
FixNameIndexAtPosition(package, "IntProperty", 94);
FixNameIndexAtPosition(package, "LightMapResolution", 114);
FixNameIndexAtPosition(package, "IntProperty", 122);
FixNameIndexAtPosition(package, "None", 142);
stream.Write(minimalByteArray, 0, serialSize);
}
public static void AddNamesToNameTable(UnrealPackage package)
{
var namesToAdd = new List <string>()
{
"SizeX", "IntProperty", "SizeY", "OriginalSizeX",
"OriginalSizeY", "Format", "ByteProperty", "EPixelFormat",
"PF_A8R8G8B8", "bIsSourceArtUncompressed", "BoolProperty", "CompressionNone",
"MipGenSettings", "TextureMipGenSettings", "TMGS_NoMipmaps",
"LightingGuid", "StructProperty", "Guid", "None"
};
foreach (var name in namesToAdd)
{
if (!package.Names.Any((o) => o.Name == name))
{
package.Names.Add(new UNameTableItem()
{
Name = name, Flags = 1970393556451328
});
}
}
}
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
if (e.Node.Nodes.Count == 0)
{
CurrentPackage = Manager.LoadPackage(e.Node.Text);
CurrentPackage.RegisterClass("StaticMesh", typeof(UStaticMesh));
CurrentPackage.RegisterClass("Shader", typeof(UShader));
CurrentPackage.InitializePackage();
dataGridView1.Rows.Clear();
foreach (UObject obj in CurrentPackage.Objects)
{
if (obj.ExportTable != null)
{
// add only supported objects
if (obj.IsClassType("Texture") || obj.IsClassType("Texture2D") || obj.IsClassType("Sound") || obj.IsClassType("SoundCue") || obj.IsClassType("StaticMesh"))
{
this.dataGridView1.Rows.Add(obj.Name);
}
}
}
}
}
private static void FullyLoadImportPackages(UnrealPackage package, string packageFolder)
{
var packagesToLoad =
package.Imports.Where(i => i.ClassName == "Package" && i.ObjectName != package.PackageName)
.Select(i => i.ObjectName.ToString()).ToList();
foreach (var depPackage in packagesToLoad)
{
if (_LoadedPackages.ContainsKey(depPackage))
{
continue;
}
var packagePath = Path.Combine(packageFolder, depPackage + ".upk");
if (!File.Exists(packagePath))
{
continue;
}
Log.Info(
$"FullyLoadImportPackages: {package.PackageName} depends on {depPackage} loading it now!");
LoadFullPackage(packagePath);
}
}
public AssetExtractor(UnrealPackage package, bool onlyExports = true)
{
this.package = package;
this.onlyExports = onlyExports;
}
public override void Write(IUnrealStream stream, UnrealPackage package)
{
FixNameIndexAtPosition(package, "None", 4);
stream.Write(minimalByteArray, 0, serialSize);
}
public bool Verify( GameBuild gb, UnrealPackage package )
{
if( _VerifyEqual
? package.Version != _MinVersion || package.LicenseeVersion != _MinLicensee
: package.Version < _MinVersion || package.Version > _MaxVersion ||
package.LicenseeVersion < _MinLicensee || package.LicenseeVersion > _MaxLicensee )
return false;
gb.Version = package.Version;
gb.LicenseeVersion = package.LicenseeVersion;
if( _IsConsoleCompressed < 2 )
{
gb.IsConsoleCompressed = _IsConsoleCompressed == 1;
}
if( _IsXenonCompressed < 2 )
{
gb.IsXenonCompressed = _IsXenonCompressed == 1;
}
return true;
}
public GameBuild( UnrealPackage package )
{
if( UnrealConfig.Platform == UnrealConfig.CookedPlatform.Console )
{
IsConsoleCompressed = true;
}
var gameBuilds = Enum.GetValues( typeof(BuildName) ) as BuildName[];
foreach( var gameBuild in gameBuilds )
{
var gameBuildMember = typeof(BuildName).GetMember( gameBuild.ToString() );
if( gameBuildMember.Length == 0 )
continue;
var attribs = gameBuildMember[0].GetCustomAttributes( false );
var game = attribs.OfType<BuildAttribute>().SingleOrDefault(attr => attr.Verify( this, package ));
if( game == null )
continue;
Name = (BuildName)Enum.Parse( typeof(BuildName), Enum.GetName( typeof(BuildName), gameBuild ) );
if( package.Decoder != null )
{
break;
}
var buildDecoderAttr = attribs.SingleOrDefault( attr => attr is BuildDecoderAttribute ) as BuildDecoderAttribute;
if( buildDecoderAttr == null )
break;
package.Decoder = buildDecoderAttr.CreateDecoder();
break;
}
if( Name == BuildName.Unset )
{
Name = package.LicenseeVersion == 0 ? BuildName.Default : BuildName.Unknown;
}
}
abstract public void Write(IUnrealStream stream, UnrealPackage package);
