UAssetAPI Documentation

UAssetAPI provides low-level read/write capabilities for Unreal Engine assets. Key features include:

• Wide Version Support: Handles cooked and uncooked .uasset files from Unreal Engine versions ~4.13 to 5.7.
• Extensive Type Support: Supports over 100 property types and 12 export types.
• Data Interchange: Supports JSON export and import using a proprietary format designed to maintain binary equality.
• Bytecode Access: Ability to read and write raw Kismet (blueprint) bytecode.
• Mapping Support: Can read unofficial .usmap files to parse ambiguous or unversioned properties.
• Resilience: Includes fail-safes for properties and exports that fail serialization.
• Extensibility: Features automatic reflection for new property types found in other loaded assemblies.

The AC7Decrypt class in the UAssetAPI namespace provides tools to decrypt and encrypt Ace Combat 7 assets. It supports both file-based operations (reading from and writing to disk) and in-memory byte array operations using an AC7XorKey.

using UAssetAPI;

// Example of initializing the decryptor
var decryptor = new AC7Decrypt();

If an error occurs during the parsing of ScriptBytecode, the StructExport object provides fallback fields to ensure you can still access the underlying script data:

1. Check ScriptBytecodeSize for the total size of the bytecode in deserialized memory.
2. Use ScriptBytecodeRaw to access the raw Byte[] binary data directly.

In the UAssetAPI.PropertyTypes.Objects namespace, AssetObjectPropertyData describes a reference variable to another object. This reference may be null and can become valid or invalid at any point during the asset lifecycle. It is a near synonym for SoftObjectPropertyData.

Key characteristics:

• It implements ICloneable.
• It is decorated with JsonObjectAttribute.
• It provides access to the property's Value (as an FString), RawValue (as an object), and PropertyType (as an FString).

// Example instantiation
var property = new AssetObjectPropertyData(new FName("MyObjectReference"));

The FTopLevelAssetPath struct in the UAssetAPI.PropertyTypes.Objects namespace is used to represent a top-level path to an asset within an Unreal Engine package. It consists of two primary fields: PackageName and AssetName.

Field Behavior based on Unreal Engine Version:

• PackageName: The name of the package containing the asset (e.g., /Path/To/Package). Note that for Unreal Engine versions earlier than 5.1, this field may be null.
• AssetName: The name of the asset within the package (e.g., AssetName). Note that for Unreal Engine versions earlier than 5.1, this field contains the full path instead of just the asset name.

// Example of the struct definition
public struct FTopLevelAssetPath
{
    public FName PackageName;
    public FName AssetName;
}

In the UAssetAPI.PropertyTypes.Objects namespace, FSoftObjectPath is a struct used as a reference variable to another object. This reference may be null and its validity can change over time. It represents a path to an asset, optionally including a sub-path to a specific subobject within that asset.

public struct FSoftObjectPath

In the UAssetAPI.PropertyTypes.Objects namespace, PropertyData is an abstract base class representing a generic Unreal property. It serves as the foundation for all specific property types in the API. It implements ICloneable for deep copying and is decorated with JsonObjectAttribute for serialization.

Key responsibilities include:

• Managing property metadata (Name, Type, Ancestry).
• Handling serialization and deserialization via Read and Write methods.
• Providing access to the underlying property value through RawValue or typed GetObject<T>() calls.

// PropertyData is abstract and must be used via its derived types
// or instantiated via specific constructors if available.
public abstract class PropertyData : System.ICloneable

You can initialize an empty UAsset instance using the parameterless constructor or constructors that only take configuration parameters (like EngineVersion or ObjectVersion). This instance will not contain any data until you manually call the UAsset.Read(AssetBinaryReader, Int32[], Int32[]) method.

// Create an empty instance
var asset = new UAsset();

// Later, manually load data into it
asset.Read(reader, offsetArray, lengthArray);

In UAssetAPI.ExportTypes, the RawExport class serves as a fallback mechanism. When UAssetAPI encounters an export that it cannot properly parse into a structured format, it represents that export as a RawExport object containing the raw byte array. This allows you to still access metadata (like ObjectName and ObjectFlags) even if the internal object data is unreadable by the parser.

// Example of how a RawExport might be used conceptually when parsing fails
if (export is RawExport raw)
{
    byte[] rawData = raw.Data;
    string name = raw.ObjectName.ToString();
    // Handle the unparsed data manually
}