public override bool Export(ProjectAssetContainer container, string dirPath) { TryInitialize(container); string folderPath = Path.Combine(dirPath, Object.AssetsKeyWord, OcclusionCullingSettings.SceneKeyWord); string sceneSubPath = GetSceneName(container); string fileName = $"{sceneSubPath}.unity"; string filePath = Path.Combine(folderPath, fileName); folderPath = Path.GetDirectoryName(filePath); if (!DirectoryUtils.Exists(folderPath)) { DirectoryUtils.CreateDirectory(folderPath); } AssetExporter.Export(container, Components, filePath); SceneImporter sceneImporter = new SceneImporter(); Meta meta = new Meta(sceneImporter, GUID); ExportMeta(container, meta, filePath); string sceneName = Path.GetFileName(sceneSubPath); string subFolderPath = Path.Combine(folderPath, sceneName); if (OcclusionCullingData != null) { ExportAsset(container, OcclusionCullingData, subFolderPath); } return(true); }
public void Export(ProjectAssetContainer container, IEnumerable <Object> assets, string path) { foreach (Object asset in assets) { Export(container, asset, path); } }
private void TryInitialize(ProjectAssetContainer container) { if (m_initialized) { return; } foreach (Object comp in Components) { if (comp.ClassID == ClassIDType.OcclusionCullingSettings) { OcclusionCullingSettings settings = (OcclusionCullingSettings)comp; if (OcclusionCullingSettings.IsReadPVSData(File.Version)) { if (settings.PVSData.Count > 0) { OcclusionCullingData = new OcclusionCullingData(container.VirtualFile); OcclusionCullingData.Initialize(container, settings); } } } } m_initialized = true; }
public override bool Export(ProjectAssetContainer container, string dirPath) { string folderPath = Path.Combine(dirPath, OcclusionCullingSettings.SceneExportFolder); string fileName = $"{Name}.unity"; string filePath = Path.Combine(folderPath, fileName); if (!Directory.Exists(folderPath)) { Directory.CreateDirectory(folderPath); } AssetExporter.Export(container, Components, filePath); DefaultImporter sceneImporter = new DefaultImporter(false); Meta meta = new Meta(sceneImporter, GUID); ExportMeta(container, meta, filePath); string subFolderPath = Path.Combine(folderPath, Name); if (OcclusionCullingData != null) { ExportAsset(container, OcclusionCullingData, subFolderPath); } if (LightingDataAsset != null) { ExportAsset(container, OcclusionCullingData, subFolderPath); } if (m_navMeshData != null) { ExportAsset(container, m_navMeshData, subFolderPath); } return(true); }
public void Export(ProjectAssetContainer container, Object asset, string path) { using (FileStream fileStream = new FileStream(path, FileMode.CreateNew, FileAccess.Write)) { container.File = asset.File; asset.ExportBinary(container, fileStream); } }
public void Export(string path, IEnumerable <Object> objects) { 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(objects); depSet.UnionWith(depList); for (int i = 0; i < depList.Count; i++) { Object current = depList[i]; if (!queued.Contains(current)) { IAssetExporter exporter = m_exporters[current.ClassID]; IExportCollection collection = exporter.CreateCollection(current); foreach (Object element in collection.Objects) { 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 current.FetchDependencies(true)) { if (dependency == null) { continue; } if (!depSet.Contains(dependency)) { depList.Add(dependency); depSet.Add(dependency); } } } } depList.Clear(); depSet.Clear(); queued.Clear(); ProjectAssetContainer container = new ProjectAssetContainer(this, collections); foreach (IExportCollection collection in collections) { container.CurrentCollection = collection; bool isExported = collection.Export(container, path); if (isExported) { Logger.Log(LogType.Info, LogCategory.Export, $"'{collection.Name}' exported"); } } }
protected override string ExportInner(ProjectAssetContainer container, string filePath) { if (m_convert) { string dirPath = Path.GetDirectoryName(filePath); string fileName = Path.GetFileNameWithoutExtension(filePath); filePath = $"{Path.Combine(dirPath, fileName)}.png"; } AssetExporter.Export(container, Asset, filePath); return(filePath); }
public override bool Export(ProjectAssetContainer container, string dirPath) { if (m_export.Count == 0) { return(false); } string scriptFolder = m_export[0].ExportName; string scriptPath = Path.Combine(dirPath, scriptFolder); AssetExporter.Export(container, m_export, scriptPath, OnScriptExported); return(true); }
protected void ExportAsset(ProjectAssetContainer container, IAssetImporter importer, Object asset, string path, string name) { if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } string filePath = $"{Path.Combine(path, name)}.{asset.ExportExtension}"; AssetExporter.Export(container, asset, filePath); Meta meta = new Meta(importer, asset.GUID); ExportMeta(container, meta, filePath); }
public override bool Export(ProjectAssetContainer container, string dirPath) { string subPath = Path.Combine(dirPath, "ProjectSettings"); string fileName = $"{Asset.GetType().Name}.asset"; string filePath = Path.Combine(subPath, fileName); if (!DirectoryUtils.Exists(subPath)) { DirectoryUtils.CreateDirectory(subPath); } ExportInner(container, filePath); return(true); }
public void Export(ProjectAssetContainer container, Object asset, string path) { using (FileStream fileStream = File.Open(path, FileMode.Create, FileAccess.Write)) { using (StreamWriter streamWriter = new StreamWriter(fileStream)) { YAMLWriter writer = new YAMLWriter(); container.File = asset.File; YAMLDocument doc = asset.ExportYAMLDocument(container); writer.AddDocument(doc); writer.Write(streamWriter); } } }
protected void ExportMeta(ProjectAssetContainer container, Meta meta, string filePath) { string metaPath = $"{filePath}.meta"; using (FileStream fileStream = System.IO.File.Open(metaPath, FileMode.Create, FileAccess.Write)) { using (StreamWriter streamWriter = new StreamWriter(fileStream)) { YAMLWriter writer = new YAMLWriter(); YAMLDocument doc = meta.ExportYAMLDocument(container); writer.IsWriteDefaultTag = false; writer.IsWriteVersion = false; writer.AddDocument(doc); writer.Write(streamWriter); } } }
public override bool Export(ProjectAssetContainer container, string dirPath) { string subFolder = Asset.ExportName; string subPath = Path.Combine(dirPath, subFolder); string fileName = GetUniqueFileName(Asset, subPath); string filePath = Path.Combine(subPath, fileName); if (!Directory.Exists(subPath)) { Directory.CreateDirectory(subPath); } filePath = ExportInner(container, filePath); Meta meta = new Meta(MetaImporter, Asset.GUID); ExportMeta(container, meta, filePath); return(true); }
private void TryInitialize(ProjectAssetContainer container) { if (m_initialized) { return; } foreach (Object comp in Components) { switch (comp.ClassID) { case ClassIDType.NavMeshSettings: { NavMeshSettings settings = (NavMeshSettings)comp; NavMeshData = settings.NavMeshData.FindObject(File); } break; case ClassIDType.OcclusionCullingSettings: { OcclusionCullingSettings settings = (OcclusionCullingSettings)comp; if (OcclusionCullingSettings.IsReadPVSData(File.Version)) { if (settings.PVSData.Count > 0) { OcclusionCullingData = new OcclusionCullingData(container.VirtualFile); OcclusionCullingData.Initialize(container, (byte[])settings.PVSData, settings.SceneGUID, settings.StaticRenderers, settings.Portals); } } } break; } } m_initialized = true; }
protected override string ExportInner(ProjectAssetContainer container, string filePath) { TryInitialize(container); return(base.ExportInner(container, filePath)); }
public void Export(ProjectAssetContainer container, IEnumerable <Object> assets, string path) { }
private void ExportAsset(ProjectAssetContainer container, NamedObject asset, string path) { NativeFormatImporter importer = new NativeFormatImporter(asset); ExportAsset(container, importer, asset, path, asset.Name); }
public void Export(ProjectAssetContainer container, Object asset, string path) { }
protected virtual string ExportInner(ProjectAssetContainer container, string filePath) { AssetExporter.Export(container, Asset, filePath); return(filePath); }
public abstract bool Export(ProjectAssetContainer container, string dirPath);
protected override string ExportInner(ProjectAssetContainer container, string filePath) { AssetExporter.Export(container, Objects, filePath); return(filePath); }
public bool Export(ProjectAssetContainer container, string dirPath) { return(false); }
private void TryInitialize(ProjectAssetContainer container) { if (m_initialized) { return; } AnimatorController asset = (AnimatorController)Asset; ControllerConstant controller = asset.Controller; IReadOnlyList <OffsetPtr <StateMachineConstant> > stateMachinesConst = controller.StateMachineArray; m_stateMachines = new AnimatorStateMachine[stateMachinesConst.Count]; for (int i = 0; i < stateMachinesConst.Count; i++) { StateMachineConstant stateMachineConstant = stateMachinesConst[i].Instance; AnimatorStateMachine stateMachine = new AnimatorStateMachine(container.VirtualFile, asset, i); m_stateMachines[i] = stateMachine; } for (int i = 0; i < StateMachines.Count; i++) { AnimatorStateMachine stateMachine = StateMachines[i]; StateMachineConstant stateMachineConstant = asset.Controller.StateMachineArray[i].Instance; AddAsset(stateMachine); foreach (PPtr <AnimatorStateTransition> transitionPtr in stateMachine.AnyStateTransitions) { AnimatorStateTransition transition = transitionPtr.GetAsset(container.VirtualFile); AddAsset(transition); } foreach (PPtr <AnimatorTransition> transitionPtr in stateMachine.EntryTransitions) { AnimatorTransition transition = transitionPtr.GetAsset(container.VirtualFile); AddAsset(transition); } for (int j = 0; j < stateMachine.ChildStates.Count; j++) { PPtr <AnimatorState> statePtr = stateMachine.ChildStates[j].State; AnimatorState state = statePtr.GetAsset(container.VirtualFile); StateConstant stateConstant = stateMachineConstant.StateConstantArray[j].Instance; AddAsset(state); if (state.Motion.IsVirtual) { AddBlendTree(container.VirtualFile, state.Motion.CastTo <BlendTree>()); } for (int k = 0; k < state.Transitions.Count; k++) { PPtr <AnimatorStateTransition> transitionPtr = state.Transitions[k]; AnimatorStateTransition transition = transitionPtr.GetAsset(container.VirtualFile); TransitionConstant transitionConstant = stateConstant.TransitionConstantArray[k].Instance; AddAsset(transition); } } } m_initialized = true; }