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; }