public static void SerializedValues_AreCultureInvariant()
{
var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
var model = new Model("Cube", cube.GetComponent <MeshFilter>().sharedMesh, cube.GetComponent <MeshRenderer>().sharedMaterial);
var current = Thread.CurrentThread.CurrentCulture;
try
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("de-DE");
string obj, mtl;
List <string> textures;
if (ObjExporter.Export("Cube Test", new Model[] { model }, out obj, out mtl, out textures))
{
Assert.IsFalse(obj.Any(x => x.Equals(',')));
Assert.IsFalse(mtl.Any(x => x.Equals(',')));
}
}
finally
{
Thread.CurrentThread.CurrentCulture = current;
UnityEngine.Object.DestroyImmediate(cube);
}
}
private void Start()
{
if (meshWrapper == null)
{
return;
}
var menu = new Settings.Menu(Tools.ToolType.Standard);
if (sculptors != null)
{
foreach (var sculptor in sculptors)
{
sculptor.Init(meshWrapper.SculptMesh, menu);
}
}
menu.ExportAction.OnDone += () =>
{
ObjExporter.Export(
meshWrapper.SculptMesh.Mesh,
meshWrapper.MeshTransform
);
};
}
static string DoExport(string path, IEnumerable <Model> models, ObjOptions options)
{
string name = Path.GetFileNameWithoutExtension(path);
string directory = Path.GetDirectoryName(path);
List <string> textures = null;
string obj, mat;
if (ObjExporter.Export(name, models, out obj, out mat, out textures, options))
{
try
{
FileUtility.WriteAllText(string.Format("{0}/{1}.obj", directory, name), obj);
FileUtility.WriteAllText(string.Format("{0}/{1}.mtl", directory, name.Replace(" ", "_")), mat);
CopyTextures(textures, directory);
}
catch (System.Exception e)
{
Debug.LogWarning(string.Format("Failed writing obj to path: {0}\n{1}", string.Format("{0}/{1}.obj", path, name), e.ToString()));
return(null);
}
}
else
{
Debug.LogWarning("No meshes selected.");
return(null);
}
return(path);
}
public static void ExportSingleCube_CreatesUnityReadableMeshFile(
[ValueSource("k_Handedness")] ObjOptions.Handedness handedness,
[ValueSource("k_CopyTextures")] bool copyTextures,
[ValueSource("k_ApplyTransforms")] bool applyTransforms,
[ValueSource("k_VertexColors")] bool vertexColors,
[ValueSource("k_TextureOffsetScale")] bool textureOffsetScale
)
{
var cube = ShapeGenerator.CreateShape(ShapeType.Cube);
string obj;
string mtl;
List <string> textures;
var res = ObjExporter.Export("Single cube",
new Model[] { new Model("Single Cube Mesh", cube, true) },
out obj,
out mtl,
out textures);
Assume.That(res, Is.True);
Assume.That(string.IsNullOrEmpty(obj), Is.False);
Assume.That(string.IsNullOrEmpty(mtl), Is.False);
string exportedPath = TestUtility.temporarySavedAssetsDirectory + "SingleCube.obj";
File.WriteAllText(exportedPath, obj);
AssetDatabase.ImportAsset(exportedPath);
var imported = AssetDatabase.LoadAssetAtPath(exportedPath, typeof(Mesh)) as Mesh;
Assume.That(imported, Is.Not.Null);
Assert.That(imported.vertexCount, Is.GreaterThan(0));
}
private void OnUserRequestExportMeshes()
{
var sfd = new CommonSaveFileDialog();
sfd.Title = "Save File...";
sfd.AddToMostRecentlyUsedList = false;
//sfd.EnsureFileExists = true;
//sfd.EnsurePathExists = true;
sfd.EnsureReadOnly = false;
sfd.EnsureValidNames = true;
sfd.ShowPlacesList = true;
sfd.Filters.Add(new CommonFileDialogFilter("Obj Files", "*.obj"));
sfd.Filters.Add(new CommonFileDialogFilter("All Files", "*.*"));
if (sfd.ShowDialog() == CommonFileDialogResult.Ok)
{
string directoryName = Path.GetDirectoryName(sfd.FileName);
Directory.CreateDirectory(directoryName);
for (int i = 0; i < m_loadedModels.Count; i++)
{
string exportName = Path.GetFileName(sfd.FileName);
// If they have more than one model currently loaded, export each obj
if (m_loadedModels.Count > 1)
{
exportName += string.Format("_{0}.obj", i.ToString("00"));
}
string exportPath = Path.Combine(directoryName, exportName);
ObjExporter.Export(m_loadedModels[i], exportPath);
}
}
}
public static void ExportSingleCube_CreatesUnityReadableMeshFile()
{
var cube = ShapeGenerator.CreateShape(ShapeType.Cube);
string obj;
string mtl;
List <string> textures;
var res = ObjExporter.Export("Single cube",
new Model[] { new Model("Single Cube Mesh", cube, true) },
out obj,
out mtl,
out textures);
Assume.That(res, Is.True);
Assume.That(string.IsNullOrEmpty(obj), Is.False);
Assume.That(string.IsNullOrEmpty(mtl), Is.False);
string exportedPath = TestUtility.temporarySavedAssetsDirectory + "SingleCube.obj";
File.WriteAllText(exportedPath, obj);
AssetDatabase.ImportAsset(exportedPath);
var imported = AssetDatabase.LoadAssetAtPath(exportedPath, typeof(Mesh)) as Mesh;
Assume.That(imported, Is.Not.Null);
Assert.That(imported.vertexCount, Is.GreaterThan(0));
}
private void ExportModel(string fileName = "model.obj")
{
using (var exporter = new ObjExporter(fileName))
{
exporter.Export(this.Model);
}
Process.Start("explorer.exe", "/select,\"" + fileName + "\"");
}
private void ExportFile()
{
string path = SaveFileDialog("3D model files (*.obj;|*.obj;");
if (string.IsNullOrEmpty(path))
{
return;
}
var exporter = new ObjExporter(path);
exporter.Export(ModelGeometry[0]);
exporter.Close();
MessageBox.Show($"Export Finished. {path}");
}
static void MenuInit()
{
List <string> textures;
string obj, mat;
ObjOptions options = new ObjOptions()
{
applyTransforms = false
};
if (ObjExporter.Export("probuilder cube", MeshSelection.top.Select(x => new Model("Cube", x)), out obj, out mat, out textures, options))
{
System.IO.File.WriteAllText("/Users/karlh/Desktop/cube.obj", obj);
}
}
private void ExportModel(object sender, ModelExportEventArgs args)
{
try
{
SaveUserPreferences();
var maid = GameMain.Instance.CharacterMgr.GetMaid(0);
var materialState = maid.PrepareMaterialsForExport();
try
{
var meshes = FindObjectsOfType <SkinnedMeshRenderer>()
.Where(smr => smr.name != "obj1")
.Distinct()
.ToList();
IExporter exporter;
switch (args.Format)
{
case ModelFormat.Pmx:
exporter = new PmxExporter();
break;
case ModelFormat.Obj:
exporter = new ObjExporter();
break;
default:
throw new Exception($"Unknown model format: {args.Format}");
}
exporter.ExportFolder = args.Folder;
exporter.ExportName = args.Name;
exporter.SavePostion = args.SavePosition;
exporter.SaveTexture = args.SaveTexture;
exporter.Export(meshes);
}
finally
{
maid.RestoreMaterialsAfterExport(materialState);
}
}
catch (Exception error)
{
Debug.LogError($"Error exporting {args.Format}: {error.Message}\n\nStack trace:\n{error.StackTrace}");
}
}
public static string ToObjData(Mesh mesh, ObjOptions options = null)
{
string name = mesh.name;
if (string.IsNullOrEmpty(name))
{
name = name.Replace("(Clone)", "").Trim(' ');
}
if (string.IsNullOrEmpty(name))
{
name = "default";
}
var model = new ObjExporter.Model(mesh);
ObjExporter.Export(name, new[] { model }, out string result, out string _, out List <string> _, options);
return(result);
}
/// <summary>
/// Exports all given meshes.
/// </summary>
/// <param name="mesh">Meshes to export.</param>
/// <param name="elapsedTime">Elapsed creation time for each mesh, expected to match mesh in length.</param>
public static void Export(IPolygon[] mesh, long[] elapsedTime)
{
int n = mesh.Count();
var paths = new string[n];
var exportSuccess = new bool[n];
PrintTitle("EXPORTING");
Console.WriteLine();
for (int i = 0; i < n; i++)
{
Console.WriteLine($"Choose location for export {i + 1} of {n}\n");
paths[i] = PathChooser.FindSaveLocation();
}
Parallel.For(0, n, i => {
if (paths[i] != null)
{
exportSuccess[i] = paths[i].EndsWith("obj") ? ObjExporter.Export(paths[i], mesh[i], elapsedTime[i]) : PlyExporter.Export(paths[i], mesh[i], elapsedTime[i]);
}
});
for (int i = 0; i < n; i++)
{
if (paths[i] == null)
{
Console.WriteLine($"\nExporting of file {i + 1} of {n} failed!");
continue;
}
var s = paths[i].Split('\\');
Console.WriteLine($"\nOpen generated '{s[s.Length - 1]}' file? Y/N");
Console.Write("> ");
if (Console.ReadLine().ToLower().Contains("y"))
{
Process.Start(paths[i]);
}
}
}
private void FileExportRaw()
{
var path = FileDialogService.SaveFileDialog(null, null, Exporters.Filter, ".png");
if (path == null)
{
return;
}
//HelixView.Export(path);
///*
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
var ext = Path.GetExtension(path).ToLowerInvariant();
switch (ext)
{
case ".png":
case ".jpg":
HelixView.Export(path);
break;
case ".xaml":
{
var e = new XamlExporter(path);
e.Export(CurrentModel);
e.Close();
break;
}
case ".xml":
{
var e = new KerkytheaExporter(path);
e.Export(HelixView.Viewport);
e.Close();
break;
}
case ".obj":
{
var patient = new Patient();
var e = new SmileObjExporter(path);
//e.Export(CurrentModel);
((SmileObjExporter)e).rawVisual = RawVisual;
((SmileObjExporter)e).Export(RawVisual, patient);
e.Close();
break;
}
case ".objz":
{
var tmpPath = Path.ChangeExtension(path, ".obj");
var e = new ObjExporter(tmpPath);
e.Export(CurrentModel);
e.Close();
GZipHelper.Compress(tmpPath);
break;
}
case ".x3d":
{
var e = new X3DExporter(path);
e.Export(CurrentModel);
e.Close();
break;
}
}
showStatus(stopWatch, "Exported");
//*/
}
void DrawExportPanel()
{
var settings = m_target.settings;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.BeginVertical(GUILayout.Width(indentSize));
EditorGUILayout.Space();
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical(GUILayout.Width(c1Width));
settings.inexportIndex = GUILayout.SelectionGrid(settings.inexportIndex, strInExport, 1);
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical(GUILayout.Width(spaceSize));
EditorGUILayout.Space();
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical();
if (settings.inexportIndex == 0)
{
if (GUILayout.Button("Duplicate"))
{
var dup = Instantiate(m_target.mesh);
Utils.MeshToGameObject(dup, Vector3.zero, Utils.GetMaterials(m_target.gameObject));
}
}
if (settings.inexportIndex == 1)
{
if (GUILayout.Button("Export .asset file"))
{
string path = EditorUtility.SaveFilePanel("Export .asset file", "Assets", Utils.SanitizeFileName(m_target.name), "asset");
if (path.Length > 0)
{
var dataPath = Application.dataPath;
if (!path.StartsWith(dataPath))
{
Debug.LogError("Invalid path: Path must be under " + dataPath);
}
else
{
path = path.Replace(dataPath, "Assets");
AssetDatabase.CreateAsset(Instantiate(m_target.mesh), path);
Debug.Log("Asset exported: " + path);
}
}
}
}
else if (settings.inexportIndex == 2)
{
settings.objFlipHandedness = EditorGUILayout.Toggle("Flip Handedness", settings.objFlipHandedness);
settings.objFlipFaces = EditorGUILayout.Toggle("Flip Faces", settings.objFlipFaces);
settings.objMakeSubmeshes = EditorGUILayout.Toggle("Make Submeshes", settings.objMakeSubmeshes);
settings.objApplyTransform = EditorGUILayout.Toggle("Apply Transform", settings.objApplyTransform);
settings.objIncludeChildren = EditorGUILayout.Toggle("Include Children", settings.objIncludeChildren);
if (GUILayout.Button("Export .obj file"))
{
string path = EditorUtility.SaveFilePanel("Export .obj file", "", Utils.SanitizeFileName(m_target.name), "obj");
ObjExporter.Export(m_target.gameObject, path, new ObjExporter.Settings
{
flipFaces = settings.objFlipFaces,
flipHandedness = settings.objFlipHandedness,
includeChildren = settings.objIncludeChildren,
makeSubmeshes = settings.objMakeSubmeshes,
applyTransform = settings.objApplyTransform,
});
}
}
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
}
void DrawInExportPanel()
{
var settings = m_target.settings;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.BeginVertical(GUILayout.Width(indentSize));
EditorGUILayout.Space();
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical(GUILayout.Width(c1Width));
settings.inexportIndex = GUILayout.SelectionGrid(settings.inexportIndex, strInExport, 1);
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical(GUILayout.Width(spaceSize));
EditorGUILayout.Space();
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical();
if (settings.inexportIndex == 0)
{
GUILayout.BeginHorizontal();
if (GUILayout.Button("Convert To Vertex Color"))
{
m_target.BakeToVertexColor(true);
}
if (GUILayout.Button("Convert From Vertex Color"))
{
m_target.LoadVertexColor(true);
}
GUILayout.EndHorizontal();
}
else if (settings.inexportIndex == 1)
{
settings.bakeFormat = (ImageFormat)EditorGUILayout.EnumPopup("Format", settings.bakeFormat);
settings.bakeWidth = EditorGUILayout.IntField("Width", settings.bakeWidth);
settings.bakeHeight = EditorGUILayout.IntField("Height", settings.bakeHeight);
settings.bakeSeparateSubmeshes = EditorGUILayout.Toggle("Separate Submeshes", settings.bakeSeparateSubmeshes);
if (GUILayout.Button("Bake"))
{
string path = settings.bakeFormat == ImageFormat.PNG ?
EditorUtility.SaveFilePanel("Export .png file", "", SanitizeForFileName(m_target.name) + "_normal", "png") :
EditorUtility.SaveFilePanel("Export .exr file", "", SanitizeForFileName(m_target.name) + "_normal", "exr");
m_target.BakeToTexture(settings.bakeWidth, settings.bakeHeight, path, settings.bakeFormat, settings.bakeSeparateSubmeshes);
}
}
else if (settings.inexportIndex == 2)
{
settings.bakeSource = EditorGUILayout.ObjectField("Source Texture", settings.bakeSource, typeof(Texture), true) as Texture;
if (GUILayout.Button("Load"))
{
m_target.LoadTexture(settings.bakeSource, true);
}
}
else if (settings.inexportIndex == 3)
{
if (GUILayout.Button("Export .asset file"))
{
string path = EditorUtility.SaveFilePanel("Export .asset file", "Assets", SanitizeForFileName(m_target.name), "asset");
if (path.Length > 0)
{
var dataPath = Application.dataPath;
if (!path.StartsWith(dataPath))
{
Debug.LogError("Invalid path: Path must be under " + dataPath);
}
else
{
path = path.Replace(dataPath, "Assets");
AssetDatabase.CreateAsset(Instantiate(m_target.mesh), path);
Debug.Log("Asset exported: " + path);
}
}
}
}
else if (settings.inexportIndex == 4)
{
settings.objFlipHandedness = EditorGUILayout.Toggle("Flip Handedness", settings.objFlipHandedness);
settings.objFlipFaces = EditorGUILayout.Toggle("Flip Faces", settings.objFlipFaces);
settings.objMakeSubmeshes = EditorGUILayout.Toggle("Make Submeshes", settings.objMakeSubmeshes);
settings.objApplyTransform = EditorGUILayout.Toggle("Apply Transform", settings.objApplyTransform);
settings.objIncludeChildren = EditorGUILayout.Toggle("Include Children", settings.objIncludeChildren);
if (GUILayout.Button("Export .obj file"))
{
string path = EditorUtility.SaveFilePanel("Export .obj file", "", SanitizeForFileName(m_target.name), "obj");
ObjExporter.Export(m_target.gameObject, path, new ObjExporter.Settings
{
flipFaces = settings.objFlipFaces,
flipHandedness = settings.objFlipHandedness,
includeChildren = settings.objIncludeChildren,
makeSubmeshes = settings.objMakeSubmeshes,
applyTransform = settings.objApplyTransform,
});
}
}
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
}
public void SharpDX_Export_Triangle_Valid()
{
var b1 = new MeshBuilder();
b1.AddTriangle(new Vector3(0, 0, 0), new Vector3(0, 0, 1), new Vector3(0, 1, 0));
var meshGeometry = b1.ToMeshGeometry3D();
var mesh = new MeshGeometryModel3D();
mesh.Geometry = meshGeometry;
mesh.Material = PhongMaterials.Green;
mesh.Transform = new TranslateTransform3D(2, 0, 0);
var viewport = new Viewport3DX();
viewport.Items.Add(mesh);
string temp = Path.GetTempPath();
var objPath = temp + "model.obj";
var mtlPath = temp + "model.mtl";
try
{
using (var exporter = new ObjExporter(objPath))
{
exporter.Export(viewport);
}
string contentObj = File.ReadAllText(objPath);
string expectedObj = @"mtllib ./model.mtl
o object1
g group1
usemtl mat1
v 2 0 0
v 2 1 0
v 2 0 -1
# 3 vertices
vt 0 1
vt 1 1
vt 0 0
# 3 texture coordinates
f 1/1 2/2 3/3
# 1 faces
";
Assert.AreEqual(expectedObj.Replace("\r\n", "\n"), contentObj.Replace("\r\n", "\n"));
string contentMtl = File.ReadAllText(mtlPath);
}
finally
{
if (File.Exists(objPath))
{
File.Delete(objPath);
}
if (File.Exists(mtlPath))
{
File.Delete(mtlPath);
}
}
}
public override void OnInspectorGUI()
{
EditorGUILayout.Space();
EditorGUILayout.LabelField("Low Poly Cloud Generator by NoobStudios", EditorStyles.centeredGreyMiniLabel);
EditorGUILayout.Space();
EditorGUILayout.PropertyField(verts, new GUIContent("Vertices "));
EditorGUILayout.Space();
EditorGUILayout.PropertyField(offset, new GUIContent("Offset "));
if (offset.boolValue == true)
{
EditorGUILayout.PropertyField(space, new GUIContent(" Offset Value "));
}
EditorGUILayout.Space();
EditorGUILayout.PropertyField(fill, new GUIContent("Fill "));
if (!primitive.fill)
{
EditorGUILayout.PropertyField(children, new GUIContent(" Mesh in Children "));
}
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.BeginVertical(EditorStyles.helpBox);
if (GUILayout.Button("Initialize"))
{
primitive.Initialize();
}
GUILayout.BeginHorizontal();
if (GUILayout.Button("Add Sphere"))
{
GameObject sphere = new GameObject("Sphere");
sphere.transform.position = primitive.transform.position;
sphere.transform.SetParent(primitive.transform);
sphere.AddComponent <Primitive>();
sphere.AddComponent <MeshFilter>();
sphere.AddComponent <MeshRenderer>();
}
if (GUILayout.Button("Remove Sphere"))
{
Primitive[] primitives = primitive.GetComponentsInChildren <Primitive>();
DestroyImmediate(primitives[primitives.Length - 1].gameObject);
}
GUILayout.EndHorizontal();
GUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.Space();
seed = EditorGUILayout.IntField("Seed ", seed);
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.BeginVertical(EditorStyles.helpBox);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Preview"))
{
Vector3 pos = primitive.transform.position;
primitive.transform.position = Vector3.zero;
primitive.Generate(seed);
primitive.transform.position = pos;
}
if (GUILayout.Button("Preview Random"))
{
Vector3 pos = primitive.transform.position;
primitive.transform.position = Vector3.zero;
seed = Random.Range(0, 100000);
primitive.Generate(seed);
primitive.transform.position = pos;
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
if (GUILayout.Button("Export"))
{
primitive.Generate(seed);
Vector3 pos = primitive.transform.position;
primitive.transform.position = Vector3.zero;
ObjExporter.Export(primitive.gameObject);
primitive.transform.position = pos;
}
if (GUILayout.Button("Export Random"))
{
seed = Random.Range(0, 100000);
Vector3 pos = primitive.transform.position;
primitive.transform.position = Vector3.zero;
primitive.Generate(seed);
ObjExporter.Export(primitive.gameObject);
primitive.transform.position = pos;
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
serializedObject.ApplyModifiedProperties();
}
