static bool GetMeshForPBComponent(ModelExporter exporter, ProBuilderMesh pmesh, Autodesk.Fbx.FbxNode node) { Mesh mesh = new Mesh(); MeshUtility.Compile(pmesh, mesh, s_FbxOptions.quads ? MeshTopology.Quads : MeshTopology.Triangles); var pMeshRenderer = pmesh.GetComponent <MeshRenderer>(); var sharedMaterials = pMeshRenderer ? pMeshRenderer.sharedMaterials : null; exporter.ExportMesh(mesh, node, sharedMaterials); Object.DestroyImmediate(mesh); //Need to have ExportOptions accessible to remove this reflection var exporterType = exporter.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Instance) .First(x => x.Name == "get_ExportOptions").Invoke(exporter, null).GetType(); if (exporterType == typeof(ConvertToPrefabSettingsSerialize)) { // probuilder can't handle mesh assets that may be externally reloaded, just strip pb stuff for now. StripProBuilderScripts.DoStrip(pmesh); } return(true); }
static void OnContextItem(MenuCommand command, SelectionMode mode) { GameObject[] selection = null; if (command == null || command.context == null) { // We were actually invoked from the top GameObject menu, so use the selection. selection = Selection.GetFiltered <GameObject>(mode); } else { // We were invoked from the right-click menu, so use the context of the context menu. var selected = command.context as GameObject; if (selected) { selection = new GameObject[] { selected }; } } if (selection == null || selection.Length == 0) { ModelExporter.DisplayNoSelectionDialog(); return; } Selection.objects = CreateInstantiatedModelPrefab(selection); }
public void SaveAsFBX(string Name) { #if UNITY_EDITOR string filePath = Path.Combine(Application.dataPath, "Resources/" + Name + ".fbx"); ModelExporter.ExportObject(filePath, meshFilter.gameObject); #endif }
/// <summary> /// Get the filename of the format {model}@{anim}.fbx from the given object /// </summary> /// <param name="obj"></param> /// <returns>filename for use for exporting animation clip</returns> public static string GetFileName(Object obj) { if (!ModelExporter.IsEditorClip(obj)) { // not an editor clip so just return the name of the object return(obj.name); } TimelineClip timeLineClip = GetTimelineClipFromEditorClip(obj); // if the timeline clip name already contains an @, then take this as the // filename to avoid duplicate @ if (timeLineClip.displayName.Contains("@")) { return(timeLineClip.displayName); } var goBound = GetGameObjectBoundToEditorClip(obj); if (goBound == null) { return(obj.name); } return(string.Format("{0}@{1}", goBound.name, timeLineClip.displayName)); }
private void ExportSkinnedMesh(string fileToExport, out SkinnedMeshRenderer originalSkinnedMesh, out SkinnedMeshRenderer exportedSkinnedMesh) { // add fbx to scene GameObject originalFbxObj = AssetDatabase.LoadMainAssetAtPath(fileToExport) as GameObject; Assert.IsNotNull(originalFbxObj); GameObject originalGO = GameObject.Instantiate(originalFbxObj); Assert.IsTrue(originalGO); // export fbx // get GameObject string filename = GetRandomFbxFilePath(); ModelExporter.ExportObject(filename, originalGO); var importer = AssetImporter.GetAtPath(filename) as ModelImporter; #if UNITY_2019_1_OR_NEWER importer.optimizeMeshPolygons = false; importer.optimizeMeshVertices = false; #else importer.optimizeMesh = false; #endif // UNITY_2019_1_OR_NEWER importer.SaveAndReimport(); GameObject fbxObj = AssetDatabase.LoadMainAssetAtPath(filename) as GameObject; Assert.IsTrue(fbxObj); originalSkinnedMesh = originalGO.GetComponentInChildren <SkinnedMeshRenderer> (); Assert.IsNotNull(originalSkinnedMesh); exportedSkinnedMesh = fbxObj.GetComponentInChildren <SkinnedMeshRenderer> (); Assert.IsNotNull(exportedSkinnedMesh); }
private HashSet <string> GetAnimatedGameObjects(AnimationClip[] animClips, GameObject animatorObject) { var animatedObjects = new HashSet <string>(); foreach (var clip in animClips) { foreach (EditorCurveBinding uniCurveBinding in AnimationUtility.GetCurveBindings(clip)) { Object uniObj = AnimationUtility.GetAnimatedObject(animatorObject, uniCurveBinding); if (!uniObj) { continue; } GameObject unityGo = ModelExporter.GetGameObject(uniObj); if (!unityGo) { continue; } // also it's parents up until but excluding the root (the root will have a different name) var parent = unityGo.transform; while (parent != null && parent.parent != null) { animatedObjects.Add(parent.name); parent = parent.parent; } } } return(animatedObjects); }
public void ShouldExportWithCorrectConfiguration(string tempPath) { var exporter = A.Fake <IExporter>(); var modelExporter = new ModelExporter(exporter); var projectContext = A.Fake <IProjectContext>(); var directory = A.Fake <ITemporaryDirectory>(); A.CallTo(() => directory.Path).Returns(tempPath); var simulationConfigProfile = A.Fake <IConfigurationProfile>(); var project = A.Fake <IProject>(); A.CallTo(() => project.SimulationModeConfigurationProfile).Returns(simulationConfigProfile); A.CallTo(() => projectContext.Project).Returns(project); modelExporter.ExportSimulation(projectContext, tempPath); A.CallTo( () => exporter.ExportModel( A <ExporterConfiguration> .That.Matches( x => (x.TargetDir == $@"{tempPath}\model" && x.ConfigurationProfile == simulationConfigProfile)))) .MustHaveHappened(1, Times.Exactly); }
public void TestRemoveRedundantObjects() { var root = CreateGameObject("root"); var child1 = CreateGameObject("child1", root.transform); var child2 = CreateGameObject("child2", root.transform); var root2 = CreateGameObject("root2"); // test set: root // expected result: root var result = ModelExporter.RemoveRedundantObjects(new Object[] { root }); Assert.AreEqual(1, result.Count); Assert.IsTrue(result.Contains(root)); // test set: root, child1 // expected result: root result = ModelExporter.RemoveRedundantObjects(new Object[] { root, child1 }); Assert.AreEqual(1, result.Count); Assert.IsTrue(result.Contains(root)); // test set: root, child1, child2, root2 // expected result: root, root2 result = ModelExporter.RemoveRedundantObjects(new Object[] { root, root2, child2, child1 }); Assert.AreEqual(2, result.Count); Assert.IsTrue(result.Contains(root)); Assert.IsTrue(result.Contains(root2)); // test set: child1, child2 // expected result: child1, child2 result = ModelExporter.RemoveRedundantObjects(new Object[] { child2, child1 }); Assert.AreEqual(2, result.Count); Assert.IsTrue(result.Contains(child1)); Assert.IsTrue(result.Contains(child2)); }
public void TestConvertToValidFilename() { // test already valid filenames var filename = "foobar.fbx"; var result = ModelExporter.ConvertToValidFilename(filename); Assert.AreEqual(filename, result); filename = "foo_bar 1.fbx"; result = ModelExporter.ConvertToValidFilename(filename); Assert.AreEqual(filename, result); // test invalid filenames filename = "?foo**bar///.fbx"; result = ModelExporter.ConvertToValidFilename(filename); #if UNITY_EDITOR_WIN Assert.AreEqual("_foo__bar___.fbx", result); #else Assert.AreEqual("?foo**bar___.fbx", result); #endif filename = "foo$?ba%r 2.fbx"; result = ModelExporter.ConvertToValidFilename(filename); #if UNITY_EDITOR_WIN Assert.AreEqual("foo$_ba%r 2.fbx", result); #else Assert.AreEqual("foo$?ba%r 2.fbx", result); #endif }
protected bool SelectionContainsPrefabInstanceWithAddedObjects() { var exportSet = GetToExport(); Stack <Object> stack = new Stack <Object>(exportSet); while (stack.Count > 0) { var go = ModelExporter.GetGameObject(stack.Pop()); if (!go) { continue; } if (PrefabUtility.IsAnyPrefabInstanceRoot(go) && PrefabUtility.GetAddedGameObjects(go).Count > 0) { return(true); } foreach (Transform child in go.transform) { stack.Push(child.gameObject); } } return(false); }
private void saveFileDialog1_FileOk(object sender, CancelEventArgs e) { Settings.FileName = saveFileDialog1.FileName; ModelExporter exporter = new ModelExporter(Settings); exporter.ExportDefinition(ProjectDefinition); }
public override bool Execute(IEnumerable <TimelineClip> clips) { PlayableDirector director = TimelineEditor.inspectedDirector; ModelExporter.ExportSingleTimelineClip(clips.First(), director); return(true); }
protected override bool Export() { if (string.IsNullOrEmpty(ExportFileName)) { Debug.LogError("FbxExporter: Please specify an fbx filename"); return(false); } var folderPath = ExportSettings.GetAbsoluteSavePath(FbxSavePaths[SelectedFbxPath]); var filePath = System.IO.Path.Combine(folderPath, ExportFileName + ".fbx"); if (!OverwriteExistingFile(filePath)) { return(false); } string exportResult; if (IsTimelineAnim) { exportResult = ModelExporter.ExportTimelineClip(filePath, TimelineClipToExport, PlayableDirector, SettingsObject); } else { exportResult = ModelExporter.ExportObjects(filePath, ToExport, SettingsObject); } if (!string.IsNullOrEmpty(exportResult)) { // refresh the asset database so that the file appears in the // asset folder view. AssetDatabase.Refresh(); } return(true); }
public void ExportChunksForEdit(GameObject[] toEdit, string filePath) { for (int i = 0; i < toEdit.Length; i++) { ModelExporter.ExportObject(filePath + $"/chunk{i}.fbx", toEdit[i]); } }
private static void CreateMeshAssetAndShow(Mesh mesh, string assetPath) { string outputName = "_" + System.DateTime.Now.Ticks.ToString(); var outpath = assetPath.Split(char.Parse(".")); Material matRes; if (defaultMaterial == null) { matRes = AssetDatabase.GetBuiltinExtraResource <Material>("Default-Diffuse.mat"); } else { matRes = defaultMaterial; } GameObject newObj = new GameObject(); var mf = newObj.AddComponent <MeshFilter>(); mf.sharedMesh = mesh; var mr = newObj.AddComponent <MeshRenderer>(); mr.sharedMaterial = matRes; goList.Add(newObj); ModelExporter.ExportObject(outpath[outpath.Length - 2], newObj); }
public void GameCameraTest() { var filename = GetRandomFileNamePath(); var original = FbxAnimationTest.AnimTester.CreateTargetObject("GameCamera", typeof(Camera)); var origCam = original.GetComponent <Camera>(); // Configure Game Camera origCam.fieldOfView = 59; // FBX Value range is [0.001, 600000.0] centimeters // Unity Property Inspector range is [0.01, MAX_FLT] meters // Unity Importer range is [0.3, MAX_FLT] meters origCam.nearClipPlane = 30f.Centimeters().ToMeters(); // minumum origCam.farClipPlane = 6000f; // Convert it to FBX. The asset file will be deleted automatically // on termination. var fbxAsset = ModelExporter.ExportObject( filename, original); // refresh the assetdata base so that we can query for the model AssetDatabase.Refresh(); var source = AssetDatabase.LoadMainAssetAtPath(fbxAsset) as GameObject; var srcCam = source.GetComponent <Camera>(); Assert.That(srcCam.aspect, Is.EqualTo(origCam.aspect)); Assert.That(srcCam.fieldOfView, Is.EqualTo(origCam.fieldOfView)); Assert.That(srcCam.farClipPlane, Is.EqualTo(origCam.farClipPlane)); Assert.That(srcCam.nearClipPlane, Is.EqualTo(origCam.nearClipPlane)); }
private void PushButton_Click(object sender, RoutedEventArgs e) { MessageBox.Show("Command-Windows will rapidly open and close. This is Blender" + " exporting the models in the background. Please be patient!"); var exporter = new ModelExporter(BlenderPathBox.Text, System.IO.Path.Combine(GamePathBox.Text, "Graphics"), System.IO.Path.Combine(GamePathBox.Text, "Export")); PushButton.IsEnabled = false; PushButton.Content = "Exporting... Do Not Close Window"; CancelButton.IsEnabled = false; Task.Run(() => exporter.ExportAll()) .ContinueWith(delegate { Dispatcher.Invoke(delegate { if (exporter.ExceptionObject != null) { MessageBox.Show("Error extracting, check your paths and try again. " + exporter.ExceptionObject.Message); } else { MessageBox.Show("Success! The models were sent to: " + GamePathBox.Text); (Parent as Window).Close(); } }); }); }
private void applyModelExporterOptions(ModelExporter modelExporter) { normalsCheckBox.Checked = modelExporter.CanExportNormals; normalsCheckBox.Enabled = modelExporter.CanExportNormals; textureCoordinatesCheckBox.Checked = modelExporter.CanExportTextureCoordinates; textureCoordinatesCheckBox.Enabled = modelExporter.CanExportTextureCoordinates; }
public override void Term() { #if (!DEBUG_UNITTEST) base.Term(); #endif ModelExporter.UnRegisterAllMeshCallbacks(); ModelExporter.UnRegisterAllMeshObjectCallbacks(); }
public static PSObject Save(PSObject self, string path, double width = 800, double height = 600, bool isDocument = false) { var model = (PlotModel)self.BaseObject; ModelExporter.Export(model, path, width, height, isDocument); return(AutomationNull.Value); }
private void DrawFooter() { if (GUILayout.Button("Generate")) { //TODO Generate if (PossibleToGenerate()) { StartTrackingProcess(); Generate(); } } if (GUILayout.Button("Edit Terrain Mesh")) { //Export for (int i = 0; i < terrainRoot.childCount; i++) { var chunk = terrainRoot.GetChild(i); string filePath = Application.dataPath + relativeWorkspace + $"/Chunk{i}.fbx"; ModelExporter.ExportObject(filePath, chunk.gameObject); } } if (GUILayout.Button("Start Blender")) { if (pathToBlender == null || pathToBlender == "") { string p = EditorUtility.OpenFilePanel("Location Of Blender", "", "exe"); if (p.Length != 0) { pathToBlender = p; } else { return; } } BlenderUnityCommunicator.Instance.PathToBlender = pathToBlender; BlenderUnityCommunicator.Instance.StartBlender(); } if (GUILayout.Button("Close previously opend Blender instance")) { BlenderUnityCommunicator.Instance.CloseBlender(); } GUILayout.Label(relativeWorkspace); if (GUILayout.Button("Set WorkSpace")) { SelectWorkspace(); } if (generating) { DisplayGeneratingProgress(); } }
public static void ExportGameObjects(Object[] objects, string path) { //Its working. Disable for build path = "Exported/" + path + ".fbx"; string filePath = Path.Combine(Application.dataPath, path); ModelExporter.ExportObjects(filePath, objects); Debug.Log("Exported to: " + Application.dataPath + path); }
protected override void EndRecording(RecordingSession session) { if (session == null) { throw new System.ArgumentNullException("session"); } var settings = (FbxRecorderSettings)session.settings; foreach (var input in m_Inputs) { var aInput = (AnimationInput)input; if (aInput.GameObjectRecorder == null) { continue; } var clip = new AnimationClip(); settings.FileNameGenerator.CreateDirectory(session); var absolutePath = FileNameGenerator.SanitizePath(settings.FileNameGenerator.BuildAbsolutePath(session)); var clipName = absolutePath.Replace(FileNameGenerator.SanitizePath(Application.dataPath), "Assets"); #if UNITY_2019_3_OR_NEWER var options = new Animations.CurveFilterOptions(); options.keyframeReduction = false; aInput.GameObjectRecorder.SaveToClip(clip, settings.FrameRate, options); #else aInput.GameObjectRecorder.SaveToClip(clip, settings.FrameRate); #endif var root = ((AnimationInputSettings)aInput.settings).gameObject; clip.name = "recorded_clip"; var exportSettings = new ExportModelSettingsSerialize(); exportSettings.SetAnimationSource(settings.TransferAnimationSource); exportSettings.SetAnimationDest(settings.TransferAnimationDest); exportSettings.SetObjectPosition(ExportSettings.ObjectPosition.WorldAbsolute); var toInclude = ExportSettings.Include.ModelAndAnim; if (!settings.ExportGeometry) { toInclude = ExportSettings.Include.Anim; } exportSettings.SetModelAnimIncludeOption(toInclude); var exportData = new AnimationOnlyExportData(); exportData.CollectDependencies(clip, root, exportSettings); var exportDataContainer = new Dictionary <GameObject, IExportData>(); exportDataContainer.Add(root, exportData); ModelExporter.ExportObjects(clipName, new UnityEngine.Object[] { root }, exportSettings, exportDataContainer); aInput.GameObjectRecorder.ResetRecording(); } base.EndRecording(session); }
// Export GameObjects sample function public static void ExportGameObjects(Object[] objects) { string filePath = Path.Combine(Application.dataPath, "MyGame.fbx"); ModelExporter.ExportObjects(filePath, objects); // ModelExporter.ExportObject can be used instead of // ModelExporter.ExportObjects to export a single game object }
private async Task OnExecuteAsync() { if (Models == null || InputDir == null || OutputDir == null) { return; } var exporter = new ModelExporter(Models.ToHashSet(), InputDir, OutputDir); await exporter.ExportAsync(); }
static void TryLoadFbxSupport() { if (s_FbxIsLoaded) { return; } ModelExporter.RegisterMeshCallback <ProBuilderMesh>(GetMeshForComponent, true); m_FbxOptions.quads = ProBuilderSettings.Get <bool>("Export::m_FbxQuads", SettingsScope.User, true); s_FbxIsLoaded = true; }
void loadForm_loadedEvent(object sender, CodeGenerator.Forms.DBLoadedEventArgs args) { loadForm.Hide(); ModelExporter exporter = new ModelExporter(Settings); toolStripStatusLabel1.Text = "Model Loaded"; tvModel.Nodes.Add(ProjectDefinition.GetTreeView(TreeConfiguration)); exporter.ExportDefinition(ProjectDefinition); toolStripProgressBar1.Visible = false; }
private void formatComboBox_SelectedIndexChanged(object sender, EventArgs e) { if (modelFormatComboBox.SelectedItem == null) { return; } ModelExporter modelExporter = (ModelExporter)modelFormatComboBox.SelectedItem; applyModelExporterOptions(modelExporter); }
public void Verify(int cCalls, int goCalls, bool objectResult = false) { componentCalls = 0; objectCalls = 0; this.objectResult = objectResult; ModelExporter.ExportObject(filename, tree); Assert.AreEqual(cCalls, componentCalls); Assert.AreEqual(goCalls, objectCalls); }
protected void SetGameObjectsToConvert(IEnumerable <GameObject> toConvert) { ToExport = toConvert.OrderBy(go => go.name).ToArray(); TransferAnimationSource = null; TransferAnimationDest = null; var toExport = ToExport; string fbxFileName = null; if (toExport.Length == 1) { var go = ModelExporter.GetGameObject(toExport[0]); // check if the GameObject is a model instance, use as default filename and path if it is GameObject mainAsset = ConvertToNestedPrefab.GetFbxAssetOrNull(go); if (!mainAsset) { // Use the game object's name m_prefabFileName = go.name; } else { // Use the asset's name var mainAssetRelPath = AssetDatabase.GetAssetPath(mainAsset); // remove Assets/ from beginning of path mainAssetRelPath = mainAssetRelPath.Substring("Assets".Length); m_prefabFileName = System.IO.Path.GetFileNameWithoutExtension(mainAssetRelPath); ExportSettings.AddFbxSavePath(System.IO.Path.GetDirectoryName(mainAssetRelPath)); fbxFileName = m_prefabFileName; } var fullPrefabPath = System.IO.Path.Combine(ExportSettings.PrefabAbsoluteSavePath, m_prefabFileName + ".prefab"); if (System.IO.File.Exists(fullPrefabPath)) { m_prefabFileName = System.IO.Path.GetFileNameWithoutExtension(ConvertToNestedPrefab.IncrementFileName(ExportSettings.PrefabAbsoluteSavePath, m_prefabFileName + ".prefab")); } // if only one object selected, set transfer source/dest to this object if (go) { TransferAnimationSource = go.transform; TransferAnimationDest = go.transform; } } else if (toExport.Length > 1) { m_prefabFileName = "(automatic)"; } // if there is an existing fbx file then use its name, otherwise use the same name as for the prefab this.SetFilename(fbxFileName != null? fbxFileName : m_prefabFileName); }