protected AnimatorTransitionBase(VirtualSerializedFile file, ClassIDType classID, AnimatorController controller, SelectorTransitionConstant transition) :
this(file, classID, controller, transition.ConditionConstantArray)
{
Name = string.Empty;
IsExit = false;
}
public BuildSettingsExportCollection(IAssetExporter assetExporter, VirtualSerializedFile file, Object asset) :
this(assetExporter, file, (BuildSettings)asset)
{
}
public static AnimatorState CreateVirtualInstance(VirtualSerializedFile virtualFile, AnimatorController controller, int stateMachineIndex,
int stateIndex, Vector3f position)
{
return(virtualFile.CreateAsset((assetInfo) => new AnimatorState(assetInfo, controller, stateMachineIndex, stateIndex, position)));
}
public static UnityConnectSettings CreateVirtualInstance(VirtualSerializedFile virtualFile)
{
return(virtualFile.CreateAsset((assetInfo) => new UnityConnectSettings(assetInfo, true)));
}
/*public PPtr<Motion> CreateMotion(VirtualSerializedFile file, AnimatorController controller)
* {
* if (IsBlendTree(controller.File.Version))
* {
* BlendTree blendTree = new BlendTree(file, controller, GetBlendTree(), 0);
* return PPtr<Motion>.CreateVirtualPointer(blendTree);
* }
* else
* {
* return CreateMotion(file, controller, 0);
* }
* }*/
public PPtr <Motion> CreateMotion(VirtualSerializedFile file, AnimatorController controller, int nodeIndex)
{
if (BlendTreeConstantArray.Length == 0)
{
return(default);
public void Export(string path, FileCollection fileCollection, IEnumerable <Object> assets)
{
EventExportPreparationStarted?.Invoke();
VirtualSerializedFile virtualFile = new VirtualSerializedFile();
List <IExportCollection> collections = new List <IExportCollection>();
// speed up fetching a little bit
List <Object> depList = new List <Object>();
HashSet <Object> depSet = new HashSet <Object>();
HashSet <Object> queued = new HashSet <Object>();
depList.AddRange(assets);
depSet.UnionWith(depList);
for (int i = 0; i < depList.Count; i++)
{
Object asset = depList[i];
if (!queued.Contains(asset))
{
IExportCollection collection = CreateCollection(virtualFile, asset);
foreach (Object element in collection.Assets)
{
queued.Add(element);
}
collections.Add(collection);
}
#warning TODO: if IsGenerateGUIDByContent set it should build collections and write actual references with persistent GUIS, but skip dependencies
if (Config.IsExportDependencies)
{
foreach (Object dependency in asset.FetchDependencies(true))
{
if (dependency == null)
{
continue;
}
if (!depSet.Contains(dependency))
{
depList.Add(dependency);
depSet.Add(dependency);
}
}
}
}
depList.Clear();
depSet.Clear();
queued.Clear();
EventExportPreparationFinished?.Invoke();
EventExportStarted?.Invoke();
ProjectAssetContainer container = new ProjectAssetContainer(this, fileCollection.FetchAssets(), virtualFile, collections);
for (int i = 0; i < collections.Count; i++)
{
IExportCollection collection = collections[i];
container.CurrentCollection = collection;
bool isExported = collection.Export(container, path);
if (isExported)
{
Logger.Log(LogType.Info, LogCategory.Export, $"'{collection.Name}' exported");
}
EventExportProgressUpdated?.Invoke(i, collections.Count);
}
EventExportFinished?.Invoke();
}
public SceneExportCollection(IAssetExporter assetExporter, VirtualSerializedFile virtualFile, ISerializedFile file)
{
if (assetExporter == null)
{
throw new ArgumentNullException(nameof(assetExporter));
}
if (file == null)
{
throw new ArgumentNullException(nameof(file));
}
AssetExporter = assetExporter;
Name = file.Name;
m_file = file;
foreach (Object asset in file.FetchAssets())
{
if (OcclusionCullingSettings.IsSceneCompatible(asset))
{
AddComponent(file, asset);
}
}
m_cexportIDs = m_cexportIDs.OrderBy(t => t.Key, this).ToDictionary(t => t.Key, t => t.Value);
if (OcclusionCullingSettings.IsReadSceneGUID(file.Version))
{
OcclusionCullingSettings sceneSettings = Components.Where(t => t.ClassID == ClassIDType.OcclusionCullingSettings).Select(t => (OcclusionCullingSettings)t).FirstOrDefault();
if (sceneSettings != null)
{
GUID = sceneSettings.SceneGUID;
}
}
if (GUID.IsZero)
{
if (Config.IsGenerateGUIDByContent)
{
GUID = ObjectUtils.CalculateAssetsGUID(Assets);
}
else
{
GUID = new EngineGUID(Guid.NewGuid());
}
}
if (OcclusionCullingSettings.IsReadPVSData(File.Version))
{
foreach (Object comp in Components)
{
if (comp.ClassID == ClassIDType.OcclusionCullingSettings)
{
OcclusionCullingSettings settings = (OcclusionCullingSettings)comp;
if (settings.PVSData.Count > 0)
{
m_occlusionCullingSettings = settings;
OcclusionCullingData = OcclusionCullingData.CreateVirtualInstance(virtualFile, settings);
break;
}
}
}
}
}
public ProjectAssetContainer(ProjectExporter exporter, IEnumerable <Object> assets, VirtualSerializedFile file, IReadOnlyList <IExportCollection> collections)
{
if (exporter == null)
{
throw new ArgumentNullException(nameof(exporter));
}
if (file == null)
{
throw new ArgumentNullException(nameof(file));
}
if (collections == null)
{
throw new ArgumentNullException(nameof(collections));
}
m_exporter = exporter;
VirtualFile = file;
m_collections = collections;
foreach (Object asset in assets)
{
switch (asset.ClassID)
{
case ClassIDType.BuildSettings:
m_buildSettings = (BuildSettings)asset;
break;
case ClassIDType.TagManager:
m_tagManager = (TagManager)asset;
break;
}
}
List <SceneExportCollection> scenes = new List <SceneExportCollection>();
foreach (IExportCollection collection in collections)
{
if (collection is SceneExportCollection scene)
{
scenes.Add(scene);
}
}
m_scenes = scenes.ToArray();
}
public IExportCollection CreateCollection(VirtualSerializedFile virtualFile, global::uTinyRipper.Classes.Object asset)
{
return(new EmptyCollection(this, asset));
}
public PrefabExportCollection(IAssetExporter assetExporter, VirtualSerializedFile virtualFile, Object asset) :
this(assetExporter, virtualFile, GetAssetRoot(asset))
{
}
private PrefabExportCollection(IAssetExporter assetExporter, VirtualSerializedFile virtualFile, GameObject root) :
this(assetExporter, root.File, Prefab.CreateVirtualInstance(virtualFile, root))
{
}
public PrefabExportCollection(IAssetExporter assetExporter, VirtualSerializedFile virtualFile, Object asset) :
this(assetExporter, asset.File, CreatePrefab(virtualFile, asset))
{
}
public AnimatorTransition(VirtualSerializedFile file, AnimatorController controller, SelectorTransitionConstant transition) :
base(file, ClassIDType.AnimatorTransition, controller, transition)
{
file.AddAsset(this);
}
public AnimatorTransition(VirtualSerializedFile file, AnimatorController controller, SelectorTransitionConstant transition,
IReadOnlyList <AnimatorState> states) :
this(file, controller, transition)
{
DstState = PPtr <AnimatorState> .CreateVirtualPointer(states[transition.Destination]);
}
public override IExportCollection CreateCollection(VirtualSerializedFile virtualFile, Object asset, List <Object> depList)
{
return(new TextAssetExportCollection(this, (TextAsset)asset));
}
public static OcclusionCullingData CreateVirtualInstance(VirtualSerializedFile virtualFile, OcclusionCullingSettings cullingSetting)
{
return(virtualFile.CreateAsset((assetInfo) => new OcclusionCullingData(assetInfo, cullingSetting)));
}
public static BlendTree CreateVirtualInstance(VirtualSerializedFile virtualFile, AnimatorController controller, StateConstant state, int nodeIndex)
{
return(virtualFile.CreateAsset((assetInfo) => new BlendTree(assetInfo, controller, state, nodeIndex)));
}
public IExportCollection CreateCollection(VirtualSerializedFile virtualFile, Object asset)
{
return(new EngineExportCollection(asset, virtualFile.Version));
}
public AnimatorStateMachine(VirtualSerializedFile file, AnimatorController controller, int stateMachineIndex) :
base(file.CreateAssetInfo(ClassIDType.AnimatorStateMachine))
{
ObjectHideFlags = 1;
LayerConstant layer = controller.Controller.GetLayerByStateMachineIndex(stateMachineIndex);
Name = controller.TOS[layer.Binding];
StateMachineConstant stateMachine = controller.Controller.StateMachineArray[stateMachineIndex].Instance;
int stateCount = stateMachine.StateConstantArray.Count;
int stateMachineCount = 0;
int count = stateCount + stateMachineCount;
int side = (int)Math.Ceiling(Math.Sqrt(count));
List <AnimatorState> states = new List <AnimatorState>();
m_childStates = new ChildAnimatorState[stateCount];
for (int y = 0, stateIndex = 0; y < side && stateIndex < stateCount; y++)
{
for (int x = 0; x < side && stateIndex < stateCount; x++, stateIndex++)
{
Vector3f position = new Vector3f(x * StateOffset, y * StateOffset, 0.0f);
AnimatorState state = new AnimatorState(file, controller, stateMachineIndex, stateIndex, position);
ChildAnimatorState childState = new ChildAnimatorState(state, position);
m_childStates[stateIndex] = childState;
states.Add(state);
}
}
m_childStateMachines = new ChildAnimatorStateMachine[stateMachineCount];
// set destination state for transitions here because all states has become valid only now
for (int i = 0; i < stateMachine.StateConstantArray.Count; i++)
{
AnimatorState state = states[i];
StateConstant stateConstant = stateMachine.StateConstantArray[i].Instance;
for (int j = 0; j < stateConstant.TransitionConstantArray.Count; j++)
{
long stateTransitionPath = state.Transitions[j].PathID;
AnimatorStateTransition transition = (AnimatorStateTransition)file.GetAsset(stateTransitionPath);
TransitionConstant transitionConstant = stateConstant.TransitionConstantArray[j].Instance;
if (!transitionConstant.IsExit)
{
AnimatorState destState = states[transitionConstant.DestinationState];
transition.DstState = PPtr <AnimatorState> .CreateVirtualPointer(destState);
}
}
}
m_anyStateTransitions = new PPtr <AnimatorStateTransition> [stateMachine.AnyStateTransitionConstantArray.Count];
for (int i = 0; i < stateMachine.AnyStateTransitionConstantArray.Count; i++)
{
TransitionConstant transitionConstant = stateMachine.AnyStateTransitionConstantArray[i].Instance;
AnimatorStateTransition transition = new AnimatorStateTransition(file, controller, transitionConstant, states);
m_anyStateTransitions[i] = PPtr <AnimatorStateTransition> .CreateVirtualPointer(transition);
}
m_entryTransitions = stateMachine.GetEntryTransitions(file, controller, layer.Binding, states);
m_stateMachineBehaviours = new PPtr <MonoBehaviour> [0];
AnyStatePosition = new Vector3f(0.0f, -StateOffset, 0.0f);
EntryPosition = new Vector3f(StateOffset, -StateOffset, 0.0f);
ExitPosition = new Vector3f(2.0f * StateOffset, -StateOffset, 0.0f);
ParentStateMachinePosition = new Vector3f(0.0f, -2.0f * StateOffset, 0.0f);
DefaultState = ChildStates.Count > 0 ? ChildStates[stateMachine.DefaultState].State : default;
file.AddAsset(this);
}
public void Export(string path, GameCollection fileCollection, IEnumerable <SerializedFile> files, ExportOptions options)
{
EventExportPreparationStarted?.Invoke();
LayoutInfo info = new LayoutInfo(options.Version, options.Platform, options.Flags);
AssetLayout exportLayout = new AssetLayout(info);
VirtualSerializedFile virtualFile = new VirtualSerializedFile(exportLayout);
List <IExportCollection> collections = new List <IExportCollection>();
// speed up fetching
List <Object> depList = new List <Object>();
HashSet <Object> depSet = new HashSet <Object>();
HashSet <Object> queued = new HashSet <Object>();
foreach (SerializedFile file in files)
{
foreach (Object asset in file.FetchAssets())
{
if (!options.Filter(asset))
{
continue;
}
depList.Add(asset);
depSet.Add(asset);
}
}
for (int i = 0; i < depList.Count; i++)
{
Object asset = depList[i];
if (!queued.Contains(asset))
{
IExportCollection collection = CreateCollection(virtualFile, asset, options);
foreach (Object element in collection.Assets)
{
queued.Add(element);
}
collections.Add(collection);
}
if (options.ExportDependencies)
{
DependencyContext context = new DependencyContext(exportLayout, true);
foreach (PPtr <Object> pointer in asset.FetchDependencies(context))
{
if (pointer.IsNull)
{
continue;
}
Object dependency = pointer.FindAsset(asset.File);
if (dependency == null)
{
string hierarchy = $"[{asset.File.Name}]" + asset.File.GetAssetLogString(asset.PathID) + "." + context.GetPointerPath();
Logger.Log(LogType.Warning, LogCategory.Export, $"{hierarchy}'s dependency {context.PointerName} = {pointer.ToLogString(asset.File)} wasn't found");
continue;
}
if (!depSet.Contains(dependency))
{
depList.Add(dependency);
depSet.Add(dependency);
}
}
}
}
depList.Clear();
depSet.Clear();
queued.Clear();
EventExportPreparationFinished?.Invoke();
EventExportStarted?.Invoke();
ProjectAssetContainer container = new ProjectAssetContainer(this, options, virtualFile, fileCollection.FetchAssets(), collections);
for (int i = 0; i < collections.Count; i++)
{
IExportCollection collection = collections[i];
container.CurrentCollection = collection;
bool isExported = collection.Export(container, path);
if (isExported)
{
Logger.Log(LogType.Info, LogCategory.Export, $"'{collection.Name}' exported");
}
EventExportProgressUpdated?.Invoke(i, collections.Count);
}
EventExportFinished?.Invoke();
}
public static NavMeshProjectSettings CreateVirtualInstance(VirtualSerializedFile virtualFile)
{
return(virtualFile.CreateAsset((assetInfo) => new NavMeshProjectSettings(assetInfo, true)));
}
public IExportCollection CreateCollection(VirtualSerializedFile virtualFile, Object asset)
{
return(new ScriptExportCollection(this, (MonoScript)asset));
}
public override IExportCollection CreateCollection(VirtualSerializedFile virtualFile, Object asset)
{
return(new MovieTextureExportCollection(this, (MovieTexture)asset));
}
public static AnimatorStateTransition CreateVirtualInstance(VirtualSerializedFile virtualFile, AnimatorController controller,
TransitionConstant transition, IReadOnlyList <AnimatorState> states)
{
return(virtualFile.CreateAsset((assetInfo) => new AnimatorStateTransition(assetInfo, controller, transition, states)));
}
public AnimatorControllerExportCollection(IAssetExporter assetExporter, VirtualSerializedFile virtualFile, Object asset) :
this(assetExporter, virtualFile, (AnimatorController)asset)
{
}
public static AnimatorStateTransition CreateVirtualInstance(VirtualSerializedFile virtualFile, Parameters parameters)
{
return(virtualFile.CreateAsset((assetInfo) => new AnimatorStateTransition(assetInfo, parameters)));
}
public static GraphicsSettings CreateVirtualInstance(VirtualSerializedFile virtualFile)
{
return(virtualFile.CreateAsset((assetInfo) => new GraphicsSettings(assetInfo, true)));
}
public static NetworkManager CreateVirtualInstance(VirtualSerializedFile virtualFile)
{
return(virtualFile.CreateAsset((assetInfo) => new NetworkManager(assetInfo)));
}
public IExportCollection CreateCollection(VirtualSerializedFile virtualFile, Object asset)
{
return(new AudioExportCollection(this, (AudioClip)asset));
}
protected AnimatorTransitionBase(VirtualSerializedFile file, ClassIDType classID, AnimatorController controller, TransitionConstant transition) :
this(file, classID, controller, transition.ConditionConstantArray)
{
Name = controller.TOS[transition.UserID];
IsExit = transition.IsExit;
}
