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