|
public static MeshToFile ( |
||
| mf | ||
| directory | string | |
| filename | string | |
| return | void | |
void Awake()
{
// save the parent GO-s pos+rot
Vector3 position = transform.position;
Quaternion rotation = transform.rotation;
// move to the origin for combining
transform.position = Vector3.zero;
transform.rotation = Quaternion.identity;
MeshFilter[] filters = GetComponentsInChildren <MeshFilter>();
List <CombineInstance> combine = new List <CombineInstance>();
for (int i = 0; i < filters.Length; i++)
{
// skip the empty parent GO
if (filters[i].sharedMesh == null)
{
continue;
}
// combine submeshes
for (int j = 0; j < filters[i].sharedMesh.subMeshCount; j++)
{
CombineInstance ci = new CombineInstance();
ci.mesh = filters[i].sharedMesh;
ci.subMeshIndex = j;
ci.transform = filters[i].transform.localToWorldMatrix;
combine.Add(ci);
}
// disable child mesh GO-s
filters[i].gameObject.SetActive(false);
}
MeshFilter filter = GetComponent <MeshFilter>();
filter.mesh = new Mesh();
filter.mesh.CombineMeshes(combine.ToArray(), true, true);
// restore the parent GO-s pos+rot
transform.position = position;
transform.rotation = rotation;
ObjExporter.MeshToFile(filter, Application.persistentDataPath + "testobj.obj");
Mesh holderMesh = new Mesh();
ObjImporter newMesh = new ObjImporter();
holderMesh = newMesh.ImportFile(Application.persistentDataPath + "testobj.obj");
MeshRenderer renderer = g1.GetComponent <MeshRenderer>();
MeshFilter filter1 = g1.GetComponent <MeshFilter>();
filter1.mesh = holderMesh;
}
// Update is called once per frame
void Update()
{
targetObject = GameObject.FindGameObjectWithTag("Fractal");
if (combine)
{
MeshFilter[] meshFilters = targetObject.GetComponentsInChildren <MeshFilter>();
CombineInstance[] combines = new CombineInstance[meshFilters.Length];
int i = 0;
while (i < meshFilters.Length)
{
combines[i].mesh = meshFilters[i].sharedMesh;
combines[i].transform = meshFilters[i].transform.localToWorldMatrix;
i++;
//meshFilters[i].gameObject.SetActive(false);
}
transform.GetComponent <MeshFilter>().mesh = new Mesh();
transform.GetComponent <MeshFilter>().mesh.CombineMeshes(combines);
transform.GetComponent <MeshRenderer>().material = (Material)Resources.Load("combined");
combine = false;
}
if (saveObj)
{
if (transform.GetComponent <MeshFilter>().mesh != null)
{
ObjExporter.MeshToFile(transform.GetComponent <MeshFilter>(), targetObject.name + ".obj");
}
saveObj = false;
}
if (saveObjNoCombine)
{
ObjExporter.MeshToFile(targetObject.GetComponent <MeshFilter>(), "testsetset.obj");
saveObjNoCombine = false;
}
}
// Use this for initialization
void Start()
{
percent = .25f;
_mRenderer = GetComponent <MeshRenderer> ();
mf = GetComponent <MeshFilter> ();
if (_createMesh)
{
br.RegenerateMesh();
meshFromBorder = br.CloneBorderMesh;
mf.mesh = meshFromBorder;
ObjExporter.MeshToFile(mf, "MyTallerMesh.obj");
Debug.Log("Created a mesh Object in root directory");
var savePath = "Assets/" + "BorderMesh" + ".asset";
Debug.Log("Saved Mesh to:" + savePath);
#if UNITY_EDITOR
AssetDatabase.CreateAsset(mf.mesh, savePath); //This to be commented out when building
#endif
}
else
{
mf.mesh = _meshes [(int)meshSize];
}
_mRenderer.material.color = _firstColor;
// _thirdColor = _firstColor;
}
void WriteModelFiles(ThreeSceneRoot root, SceneFormat fmt)
{
// three.js는 단일 파일로 출력하는게 목적이라서 model 파일을 생성하지 않는다
var pathHelper = ExportPathHelper.Instance;
if (fmt == SceneFormat.AFrame)
{
foreach (var el in root.SharedNodeTable.GetEnumerable <MeshElem>())
{
var bufferGeom = el.Geometry as BufferGeometryElem;
if (bufferGeom != null)
{
string filepath = pathHelper.ToModelPath(bufferGeom.CreateMeshFileName(".obj"));
ObjExporter.MeshToFile(bufferGeom.Mesh, filepath);
}
var mtl = MaterialFacade.Instance.CreateMaterial(el.Material);
if (bufferGeom != null)
{
string filepath = pathHelper.ToModelPath(bufferGeom.CreateMeshFileName(".mtl"));
MtlExporter.ToFile(mtl, bufferGeom.SafeName, filepath);
}
}
}
}
public void Export()
{
if (m_bIsExportMesh)
{
if (m_strMeshName == null)
{
m_strMeshName = "meshedit_exportmesh";
}
else if (m_strMeshName.Length == 0)
{
m_strMeshName = "meshedit_exportmesh";
}
m_meshOutput.name = m_strMeshName;
// if (m_strMeshPath == null)
// {
Mesh mesh = GetComponent <MeshFilter>().sharedMesh;
GetComponent <MeshFilter> ().mesh = m_meshOutput;
ObjExporter.MeshToFile(GetComponent <MeshFilter>(), m_strMeshName);
GetComponent <MeshFilter>().mesh = mesh;
Debug.Log(name + ".Meshedit.Export(): Exported mesh to Assets", this.gameObject);
// }
// else if (m_strMeshPath.Length == 0)
// UnityEditor.AssetDatabase.CreateAsset (m_meshOutput, "Assets/" + m_strMeshPath + "/" + m_strMeshName + ".obj");
}
}
public override void OnPress()
{
// re-initialize export number so user can re-export solids if they wish to
exportNumber = initialExportNumber;
foreach (Solid solid in DCGBase.solids)
{
string filePath = "Assets/Resources/Exports/Meshes/";
string fileName = "export" + exportNumber;
filePath += fileName + ".obj";
/* create empty game object, add mesh filter and mesh renderer to it
* initialize mesh filter with meshs from dcgbase >> solids */
GameObject go = new GameObject();
MeshFilter meshFilter = go.AddComponent <MeshFilter>();
meshFilter.sharedMesh = solid.getMesh();
MeshRenderer meshRenderer = go.AddComponent <MeshRenderer>();
meshRenderer.material = exportMaterial;
Debug.Log("Exporting solid to " + filePath);
ObjExporter.MeshToFile(meshFilter, filePath);
exportNumber++;
}
StartCoroutine(displayExportedText());
base.OnPress();
}
public override void OnInspectorGUI()
{
myTargets = targets;
string filePath = EditorGUILayout.TextField("file path:", (Application.dataPath + "/RoadEditor/Exports/"));
string multiText = "";
if (myTargets.Length > 1)
{
multiText += "(multiSelected)";
}
worldMatrix = GUILayout.Toggle(worldMatrix, "Use World Space Positions");
correctedXAxisExport = GUILayout.Toggle(correctedXAxisExport, "export with inverted x-axis ");
// export
if (GUILayout.Button("Export OBJ" + multiText))
{
for (int i = 0; i < myTargets.Length; i++)
{
tempTrack = (Track)myTargets[i];
MeshFilter combineMeshFilter = tempTrack.getCombimedMeshFilter();
ObjExporter.MeshToFile(combineMeshFilter, filePath, (tempTrack.getName + ".obj"), correctedXAxisExport, worldMatrix);
DestroyImmediate(combineMeshFilter.gameObject);
}
}
EditorApplication.update += (EditorApplication.CallbackFunction)EditortUpdate;
DrawDefaultInspector();
}
// Update is called once per frame
void Update()
{
if (save)
{
ObjExporter.MeshToFile(targetObject, targetObject.name + ".obj");
save = false;
}
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
if (GUILayout.Button("Button"))
{
RotModel obj = (RotModel)target;
ObjExporter.MeshToFile(obj.Gc <MeshFilter>(), "Assets/" + obj.name + ".obj");
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
if (GUILayout.Button("Dump Mesh"))
{
MeshFilter mf = (MeshFilter)target;
ObjExporter.MeshToFile(mf, Application.dataPath + "/" + mf.name + "-" + mf.mesh.name + ".obj");
}
}
// Update is called once per frame
void Update()
{
if (once)
{
once = false;
ObjExporter.MeshToFile(meshFilter, "Assets/" + nameMesh + ".obj");
print("Mesh successfully exported : " + nameMesh + ".obj");
}
}
void createOBJ()
{
if (objMade == false)
{
objMade = true;
_vertBuffer.GetData(inValues);
print(inValues[0]);
int numVertsTotal = ribbonWidth * 3 * 2 * (ribbonLength);
AssignStructs.MeshInfo mesh = new AssignStructs.MeshInfo();
Vector3[] verts = new Vector3[ribbonLength * ribbonWidth];
Vector3[] norms = new Vector3[ribbonLength * ribbonWidth];
Vector2[] uvs = new Vector2[ribbonLength * ribbonWidth];
int[] triangles = new int[numVertsTotal];
for (int i = 0; i < ribbonWidth * ribbonLength; i++)
{
int baseID = i * AssignStructs.VertC4StructSize;
Vector3 v = new Vector3(inValues[baseID + 0], inValues[baseID + 1], inValues[baseID + 2]);
Vector3 n = new Vector3(inValues[baseID + 6], inValues[baseID + 7], inValues[baseID + 8]);
Vector2 u = new Vector2(inValues[baseID + 9], inValues[baseID + 10]);
verts[i] = v;
norms[i] = n;
uvs[i] = u;
}
for (int i = 0; i < numVertsTotal; i++)
{
triangles[i] = getID(i);
}
mesh.vertices = verts;
mesh.normals = norms;
mesh.uvs = uvs;
mesh.triangles = triangles;
mesh.name = "DONTUTEST";
//string objString = makeString( mesh , transform );
//print( objString );
//WriteToFile( objString , "DONUT_TEST.obj");
ObjExporter.MeshToFile(mesh);
}
}
void ExportMesh(GameObject obj)
{
if (fileFormatSelector.value == 0)
{
FBXExporter.ExportGameObjToFBX(obj, _path, false, false);
}
if (fileFormatSelector.value == 1)
{
ObjExporter.MeshToFile(obj.GetComponent <MeshFilter>(), _path);
}
Debug.Log("exported");
}
public override void OnInspectorGUI()
{
ObjExporter script = (ObjExporter)target;
DrawDefaultInspector();
GUILayout.Space(20);
if (GUILayout.Button("Build OBJ file"))
{
script.MeshToFile();
}
}
// Update is called once per frame
void Update()
{
if (save)
{
save = false;
ObjExporter.MeshToFile(GetComponent <MeshFilter>(), "meshyoyo.obj");
}
UpdateMiddle();
UpdateCollider();
UpdateDarts();
}
void combiner(GameObject go, Boolean save, int clr, int filenumber)
{
// save the parent GO-s pos+rot
//Vector3 position = go.transform.position;
//Quaternion rotation = go.transform.rotation;
// move to the origin for combining
//transform.position = Vector3.zero;
//transform.rotation = Quaternion.identity;
MeshFilter[] filters = go.GetComponentsInChildren <MeshFilter>();
List <CombineInstance> combine = new List <CombineInstance>();
for (int i = 0; i < filters.Length; i++)
{
// skip the empty parent GO
if (filters[i].sharedMesh == null)
{
continue;
}
// combine submeshes
for (int j = 0; j < filters[i].sharedMesh.subMeshCount; j++)
{
CombineInstance ci = new CombineInstance();
ci.mesh = filters[i].sharedMesh;
ci.subMeshIndex = j;
ci.transform = filters[i].transform.localToWorldMatrix;
combine.Add(ci);
}
// disable child mesh GO-s
filters[i].gameObject.SetActive(false);
}
MeshFilter filter = go.GetComponent <MeshFilter>();
filter.mesh = new Mesh();
filter.mesh.CombineMeshes(combine.ToArray(), true, true);
// restore the parent GO-s pos+rot
//go.transform.position = position;
//go.transform.rotation = rotation;
if (save)
{
ObjExporter.MeshToFile(filter, Application.persistentDataPath + "testobject" + clr.ToString() + filenumber.ToString() + ".obj");
}
}
void CutMesh(Mesh cutMesh, GameObject cutMeshGO, string name)
{
string cutMeshOff = ObjectFileFormat.MeshToOff(cutMesh, cutMeshGO.transform);
StreamWriter strw = new StreamWriter("./Assets/Models/" + cutMeshGO.name + ".off");
strw.Write(cutMeshOff);
strw.Close();
string cuttedMeshOff = System.IO.File.ReadAllText("./Assets/Models/squirrel.off");
StringBuilder strB = new StringBuilder();
//Extract transformation matrix
Matrix4x4 transformationMatrix = cuttedMeshTransform.localToWorldMatrix;
strB.Append(transformationMatrix.m00).AppendLine();
strB.Append(transformationMatrix.m01).AppendLine();
strB.Append(transformationMatrix.m02).AppendLine();
strB.Append(transformationMatrix.m03).AppendLine();
strB.Append(transformationMatrix.m10).AppendLine();
strB.Append(transformationMatrix.m11).AppendLine();
strB.Append(transformationMatrix.m12).AppendLine();
strB.Append(transformationMatrix.m13).AppendLine();
strB.Append(transformationMatrix.m20).AppendLine();
strB.Append(transformationMatrix.m21).AppendLine();
strB.Append(transformationMatrix.m22).AppendLine();
strB.Append(transformationMatrix.m23).AppendLine();
strw = new StreamWriter("./Assets/models/matrix.txt");
strw.Write(strB.ToString());
strw.Close();
IntPtr cuttedMeshPtr = Marshal.StringToHGlobalAnsi(cuttedMeshOff);
IntPtr cuttedMeshTransformPtr = Marshal.StringToHGlobalAnsi(strB.ToString());
IntPtr cutMeshPtr = Marshal.StringToHGlobalAnsi(cutMeshOff);
IntPtr ptrResult = CGALController.booleanOperationClean(cuttedMeshPtr, cuttedMeshTransformPtr, cutMeshPtr, Marshal.StringToHGlobalAnsi("difference"));
//Convert IntPtr to string
string result = Marshal.PtrToStringAnsi(ptrResult);
//exportOff (result, "mesh" + Time.fixedDeltaTime);
// Open string stream on the result off string
byte[] byteArray = Encoding.UTF8.GetBytes(result);
MemoryStream stream = new MemoryStream(byteArray);
//Convert off string to Mesh and add it to scene
Mesh myMesh = ObjectFileFormat.OffToMesh(new StreamReader(stream));
stream.Close();
myMesh.RecalculateNormals();
ObjExporter.MeshToFile(myMesh, name, "BenchMat");
addMeshToSceneAndExport(name, myMesh, transform.GetComponent <Transform> ().localScale.x);
}
/**
* \brief Exports an OBJ file to the supplied path.
* Files sharing a path name will not be ovewritten.
* \returns The path to the generated OBJ file.
* @param path The file path to save the resulting OBJ to.
* @param mf The MeshFilter to convert to an OBJ.
*/
public string ExportOBJ(string path, MeshFilter mf)
{
if (File.Exists(path))
{
int i = 0;
while (File.Exists(path))
{
path = path.Replace(".obj", "");
path = path + i + ".obj";
i++;
}
}
ObjExporter.MeshToFile(mf, path);
return(path);
}
public void exportObject(GameObject parentObject)
{
parentObject.transform.position = new Vector3(0, 0.5f, 0);
parentObject.transform.localScale = new Vector3(100, 100, 100);
Transform[] allChildren = GameObject.Find("ObjFactory").GetComponentsInChildren <Transform>();
foreach (Transform child in GameObject.Find("ObjFactory").transform)
{
if (child.gameObject.activeSelf == true)
{
meshObjectList.Add(child.gameObject);
}
}
//meshObjectList.Add(GO1);
//meshObjectList.Add(Go2);
// combine meshes
CombineInstance[] combine = new CombineInstance[meshObjectList.Count];
int i = 0;
while (i < meshObjectList.Count)
{
MeshFilter meshFilter1 = meshObjectList[i].gameObject.GetComponent <MeshFilter>();
combine[i].mesh = meshFilter1.sharedMesh;
combine[i].transform = meshFilter1.transform.localToWorldMatrix;
i++;
}
Mesh combinedMesh = new Mesh();
combinedMesh.CombineMeshes(combine);
//Mesh mesh = CombineMeshes(new List<Mesh> { GO1.GetComponent<MeshFilter>().mesh, Go2.GetComponent<MeshFilter>().mesh });
//Debug.Log(mesh.ToString());
parentObject.AddComponent <MeshFilter>().mesh = combinedMesh;
string path = Application.persistentDataPath + "/exporrted.OBJ";
MeshFilter meshFilter = parentObject.GetComponent <MeshFilter>();
Debug.Log(meshFilter.name);
ObjExporter.MeshToFile(meshFilter, path);
ImportFile importFile = new ImportFile();
importFile._FileData.filePath = path;
importFile._FileData.fileName = Path.GetFileName(path);
importFile.SaveIntoJson();
SceneManager.LoadScene("PlaceIt");
}
void Export()
{
string sceneName = System.IO.Path.GetFileNameWithoutExtension(EditorApplication.currentScene);
foreach (var mesh in generatedObject.transform.GetComponentsInChildren <MeshFilter>())
{
string exportPath = "Assets/" + sceneName + "/" + name + "/" + mesh.name + ".obj";
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(exportPath));
ObjExporter.MeshToFile(mesh, exportPath);
AssetDatabase.ImportAsset(exportPath);
var importer = (ModelImporter)ModelImporter.GetAtPath(exportPath);
importer.animationType = ModelImporterAnimationType.None;
}
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.B))
{
Mesh mesh = new Mesh();
mesh.SetVertices(Verts);
mesh.SetUVs(0, UV);
mesh.SetNormals(Normals);
mesh.SetTriangles(Tris, 0);
meshFilter.mesh = mesh;
}
else if (Input.GetKeyDown(KeyCode.S))
{
ObjExporter.MeshToFile(meshFilter, "Assets/" + FileName);
}
}
private Mesh CutMesh(Mesh cutMesh, GameObject cutMeshGO, string cuttedGoName, string cuttedMeshOff, string cuttedMeshMatrix)
{
/* ********** handle cut mesh ********** */
string cutMeshOff = ObjectFileFormat.MeshToOff(cutMesh, cutMeshGO.transform);
IntPtr cutMeshPtr = Marshal.StringToHGlobalAnsi(cutMeshOff);
IntPtr cutMeshTransformPtr = Marshal.StringToHGlobalAnsi(GeomUtils.GetTransformationMatrix(cutMeshGO.transform, 0f, 0f, 0f));
//exportOff
//ExportOff(cutMeshOff, "./Assets/" + cutMeshGO.name + ".off");
/* ********** handle cutted mesh ********** */
IntPtr cuttedMeshPtr = Marshal.StringToHGlobalAnsi(cuttedMeshOff);
IntPtr cuttedMeshTransformPtr = Marshal.StringToHGlobalAnsi(cuttedMeshMatrix);
//exportOff
//ExportOff(cuttedMeshOff, "./Assets/" + cuttedGoName + ".off");
/* ********** compute cut with CGAL********** */
IntPtr ptrResult = CGALPlugin.BooleanOperationClean(cuttedMeshPtr, cuttedMeshTransformPtr, cutMeshPtr, cutMeshTransformPtr, Marshal.StringToHGlobalAnsi("difference"));
//Convert IntPtr to string
string result = Marshal.PtrToStringAnsi(ptrResult);
//exportOff
//ExportOff(result, DataPath + initialObjectName + parts + ".off");
// Open string stream on the result off string
byte[] byteArray = Encoding.UTF8.GetBytes(result);
MemoryStream stream = new MemoryStream(byteArray);
//Convert off string to Mesh and add it to scene
Mesh myMesh = ObjectFileFormat.OffToMesh(new StreamReader(stream));
stream.Close();
myMesh.RecalculateNormals();
//Export obj file
ObjExporter.MeshToFile(myMesh, "Split-" + DateTime.Now.ToString("hhmmssffff"), "BenchMat");
#if UNITY_EDITOR
AssetDatabase.Refresh();
#endif
return(myMesh);
}
// Update is called once per frame
void Update()
{
if (reset)
{
resetAvatar();
}
else
{
if (checkAndUpdate())
{
sizeAvatar();
}
}
if (Input.GetKeyDown(KeyCode.Space) && !IsInvoking("updateFromFile"))
{
//InvokeRepeating ("updateFromFile", 5, 30);
Invoke("updateFromFile", 5);
}
if (SaveObj)
{
MeshFilter thisMesh = GetComponent <MeshFilter> () as MeshFilter;
ObjExporter.MeshToFile(thisMesh, "Human2.obj");
SaveObj = false;
}
// if (tmpBody != null) {
//
// if (tmpBody.vertexIndexsPerBone.ContainsKey (boneType)) {
// MeshFilter thisMesh = GetComponent<MeshFilter> () as MeshFilter;
// if (thisMesh == null) {
// Debug.LogError ("No mesh filter");
// return;
// }
// Color[] colors = thisMesh.mesh.colors;
// ArrayList indexList = tmpBody.vertexIndexsPerBone [boneType];
// for (int i = 0; i < indexList.Count; ++i) {
// colors [(int)indexList [i]] =
// Color.Lerp (Color.red, Color.green, 10);//vertices[i].y);
// }
// thisMesh.mesh.colors = colors;
// }
// }
}
static void ExportNavMeshToObj()
{
var navMeshInfo = UnityEngine.AI.NavMesh.CalculateTriangulation();
Mesh mesh = new Mesh();
mesh.vertices = navMeshInfo.vertices;
mesh.triangles = navMeshInfo.indices;
mesh.RecalculateNormals();
mesh.RecalculateBounds();
GameObject navMeshFilter = new GameObject("navMeshFilter");
MeshFilter meshFilter = (navMeshFilter.AddComponent <MeshFilter>() as MeshFilter);
meshFilter.sharedMesh = mesh;
MeshRenderer meshRenderer = navMeshFilter.AddComponent <MeshRenderer>();
Material material = new Material(Shader.Find("Unlit/Transparent"));
meshRenderer.sharedMaterial = material;
string sceneId = EditorSceneManager.GetActiveScene().path;
int beignIndex = sceneId.LastIndexOf("/");
int endIndex = sceneId.LastIndexOf(".");
if (beignIndex == -1 || endIndex == -1)
{
return;
}
sceneId = sceneId.Substring(beignIndex + 1, endIndex - beignIndex - 1);
String exportPath = EditorUtility.SaveFilePanel("Save Navmesh", "", sceneId, "obj");
if (exportPath.Length > 0)
{
ObjExporter.MeshToFile(meshFilter, exportPath);
}
}
void WriteModelFiles(ThreeSceneRoot root, SceneFormat fmt)
{
// three.js는 단일 파일로 출력하는게 목적이라서 model 파일을 생성하지 않는다
var pathHelper = ExportPathHelper.Instance;
if (fmt == SceneFormat.AFrame)
{
foreach (var el in root.SharedNodeTable.GetEnumerable <AbstractGeometryElem>())
{
// TODO 타입에 따라서 obj 굽는게 바뀔텐데
var bufferGeom = el as BufferGeometryElem;
if (bufferGeom == null)
{
continue;
}
string filepath = pathHelper.ToModelPath(bufferGeom.CreateMeshFileName(".obj"));
ObjExporter.MeshToFile(bufferGeom.Mesh, filepath);
}
}
}
/**
* \brief Exports all selected Transform meshes to an OBJ file in the supplied path.
* Files sharing a path name will not be ovewritten.
* \returns The path to the generated OBJ(s) file.
* @param path The file path to save the resulting OBJ to.
* @param t_arr An array of Transforms to be parsed. Typical use case for this would be in editor, calling Selection.transforms.
*/
public static string ExportOBJ(string path, Transform[] t_arr)
{
foreach (Transform t in t_arr)
{
if (File.Exists(path))
{
int i = 0;
while (File.Exists(path))
{
path = path.Replace(".obj", "");
path = path + i + ".obj";
i++;
}
}
if (t.GetComponent <MeshFilter>())
{
ObjExporter.MeshToFile(t.GetComponent <MeshFilter>(), path);
}
}
return(path);
}
public void saveToFile()
{
MeshFilter filter = GetComponent <MeshFilter>();
if (filter)
{
string filename = "terrain " + DateTime.UtcNow.ToString() + ".obj";
// Replace '/', ':' and ' ' with '_'
filename = filename.Replace(' ', '_');
filename = filename.Replace('/', '_');
filename = filename.Replace(':', '_');
Debug.Log(filename);
ObjExporter.MeshToFile(filter, filename);
}
else
{
Debug.Log("No MeshFilter attached.");
}
}
// Use this for initialization
IEnumerator Start()
{
Loom.Current.GetComponent<Loom>();
layerMask = 1 << 8;
wayList = new List<long>();
//StartCoroutine(LoadChunk(-8.6f,41.1767f,-8.55f,41.1923f));
MapChunkLoader.precision = GeoUTMConverter.Precision;
GeoUTMConverter latlon2Utm = new GeoUTMConverter();
latlon2Utm.ToUTM((minimumLat+maximumLat)/2f,(minimumLon+maximumLon)/2f);
transform.position = new Vector3(((float)latlon2Utm.X - offsetPositionX), -0.1f, ((float)latlon2Utm.Y - offsetPositionZ));
GameObject floor = new GameObject();
floor.name = "Ground";
floor.isStatic = true;
CreateGround cg = new CreateGround();
cg.maxLat = maximumLat + 0.01f * (maximumLat - minimumLat); //0.0001f;
cg.maxLon = maximumLon + 0.01f * (maximumLat - minimumLat);
cg.minLat = minimumLat - 0.01f * (maximumLat - minimumLat);
cg.minLon = minimumLon - 0.01f * (maximumLat - minimumLat);
cg.numberOfDivisions = numberOfDivisions;
MeshFilter mf = floor.AddComponent<MeshFilter>();
MeshRenderer mr = floor.AddComponent<MeshRenderer>();
mr.material = groundMaterial;
floor.transform.position = transform.position;
floor.transform.parent = transform;
floor.layer = LayerMask.NameToLayer("RayCast");
string floorPath = Application.persistentDataPath + "Assets/Resources/Objs/" + cg.maxLat + "I" + cg.maxLon + ".obj";
if (!File.Exists(floorPath)) // If the file isn't cached we calculate everything and then we cache it
{
mf.sharedMesh = cg.GetGroundMesh();
if (exportObjs)
{
ObjExporter oe = new ObjExporter();
oe.MeshToFile(mf, floorPath);
}
}
else
{
ObjImporter oi = new ObjImporter();
StartCoroutine(oi.FileToMesh("file://" + floorPath));
while (oi._myMesh == null)
{
yield return null;
}
mf.sharedMesh = oi._myMesh;
Debug.LogWarning("Loaded Ground Chunk from cache");
}
//Texture2D t = new Texture2D(1024, 1024);
MapTexture mt = new MapTexture();
mt.getTexture(cg.minLon.ToString(), cg.minLat.ToString(), cg.maxLon.ToString(), cg.maxLat.ToString(),Application.persistentDataPath,mr.material);
while (mt.texture == null)
{
yield return null;
}
//t.LoadImage(mt.ReadFully(mt.mq_dataStream));
//mr.material.SetTexture("_MainTex", t);
MeshCollider m = floor.AddComponent<MeshCollider>();
Loom l = Loom.Current;
LoadChunk(minimumLon, minimumLat, maximumLon, maximumLat);
//StartCoroutine();
}
// Update is called once per frame
void Update()
{
//ROTATION
//rotate entire mesh (including free vertices) when L index trigger is pushed
if (OVRInput.Get(OVRInput.RawButton.LIndexTrigger))
{
//Archived
//Quaternion offset = Quaternion.Inverse(controllerOrientation) * OVRInput.GetLocalControllerRotation(OVRInput.Controller.LTouch);
// controllerOrientation = OVRInput.GetLocalControllerRotation(OVRInput.Controller.LTouch);
//meshSpace.transform.rotation = meshSpace.transform.rotation * offset;
meshSpace.transform.SetParent(this.transform, true);
}
//OPEN MENU if thumbstick is moved
if (OVRInput.Get(OVRInput.RawAxis2D.LThumbstick) != Vector2.zero)
{
if (!pieMenu.isOpen())
{
pieMenu.Open();
}
pieMenu.CustomInputVector = OVRInput.Get(OVRInput.RawAxis2D.LThumbstick);
}
else
//SELECT and CLOSE MENU when thumbstick is released
{
if (pieMenu.isOpen())
{
//select menu item by pressing thumbstick
pieMenu.confirmSelect();
pieMenu.Close();
}
}
//Export mesh when X is pushed
if (OVRInput.GetDown(OVRInput.RawButton.X))
{
string savePath = "C:/Users/Davide/Desktop/export.obj";
MeshFilter mf = targetMeshObj.GetComponent <MeshFilter>();
//add UVs
Vector2[] uvs = UvCalculator.CalculateUVs(mf.mesh.vertices, 1.0f);
mf.mesh.uv = uvs;
ObjExporter.MeshToFile(mf, savePath);
}
//Import mesh when Y is pushed
//This should only be called at the beginning of the game (no custom mesh created) for now
if (OVRInput.GetDown(OVRInput.RawButton.Y))
{
string loadPath = "C:/Users/Davide/Desktop/export.obj";
Mesh m = new Mesh();
ObjImporter importer = new ObjImporter();
m = importer.ImportFile(loadPath);
//DEBUG
//print("\nLENGTH 1");
//print((m.vertices.Length).ToString());
//print((m.triangles.Length).ToString());
//a hack to correct the doubling of triangles caused by import script
int[] correctTriangles = new int[m.vertices.Length];
for (int i = 0; i < m.vertices.Length; i++)
{
correctTriangles[i] = i;
}
m.triangles = correctTriangles;
Material mat = new Material(Shader.Find("Custom/VertexColored"));
if (targetMeshObj.GetComponent <MeshRenderer>() == null)
{
targetMeshObj.AddComponent <MeshRenderer>();
}
targetMeshObj.GetComponent <MeshFilter>().mesh = m;
targetMeshObj.GetComponent <MeshRenderer>().material = mat;
//scale
//targetMeshObj.transform.localScale = new Vector3(0.005f, 0.005f, 0.005f);
//targetMeshObj.transform.Translate(0, 0, 2f);
//DEBUG
//print("\nLENGTH 2");
//print((m.vertices.Length).ToString());
//print((m.triangles.Length).ToString());
//create vertices and related behind-the-scenes data for editing
rightHandAnchor.GetComponent <MeshHandler>().PrepareImportedMesh();
}
}
public override IEnumerator Build(Way w, MapChunkLoader mcl)
{
//CreateBuilding(Way w)
Mesh roofm = new Mesh();
Mesh wallsm = new Mesh();
GameObject build = new GameObject();
build.name = "Building - " + w.id.ToString();
build.transform.parent = mcl.transform;
GameObject roof = new GameObject();
//roof.transform.position = new Vector3(0,baseHeight,0);
roof.name = "Roof - " +(2 * w.id).ToString();
mcl.mapManager.mapHash.Add(2 * w.id);
mcl.wayList.Add(2 * w.id);
GameObject walls = new GameObject();
walls.name = "Walls - " + (3 * w.id).ToString();
//walls.transform.position = new Vector3(0,baseHeight,0);
mcl.mapManager.mapHash.Add(3 * w.id);
mcl.wayList.Add(3 * w.id);
walls.AddComponent<MeshCollider>();
walls.AddComponent(typeof(MeshRenderer));
MeshFilter filter = walls.AddComponent(typeof(MeshFilter)) as MeshFilter;
roof.AddComponent<MeshCollider>();
roof.AddComponent(typeof(MeshRenderer));
MeshFilter filter2 = roof.AddComponent(typeof(MeshFilter)) as MeshFilter;
string buildPath = Application.persistentDataPath + "Assets/Resources/Objs/" + build.name + ".obj";
string roofPath = Application.persistentDataPath+"Assets/Resources/Objs/" + roof.name + ".obj";
if (!File.Exists(buildPath) && !File.Exists(roofPath)) // If the file isn't cached we calculate everything and then we cache it
{
Vector3[] nodes = new Vector3[w.nodes.Count];
Vector2[] xz = new Vector2[w.nodes.Count];
float height = (float)w.nodes[0].northing % referenceVariationHeight + referenceBaseHeight;
if (w.height != 0)
{
height = w.height;
referenceVariationHeight = Mathf.Abs(referenceVariationHeight - height);
referenceBaseHeight = (referenceBaseHeight + height) / 2;
}
Vector3 centroid = new Vector3();
Vector3 position;
RaycastHit hit;
for (int a = 0; a < w.nodes.Count; a++)
{
yield return null;
Node n = w.nodes[a];
position = new Vector3((float)((n.easthing - mcl.offsetPositionX) / MapChunkLoader.precision), 5000, (float)((n.northing - mcl.offsetPositionZ) / MapChunkLoader.precision));
float castH = 0;
if (Physics.Raycast(position, -Vector3.up, out hit, Mathf.Infinity, mcl.layerMask))
{
castH = hit.point.y;
}
nodes[a] = new Vector3(position.x, castH + height, position.z);
xz[a] = new Vector2(position.x, position.z);
centroid += nodes[a];
}
centroid /= w.nodes.Count;
centroid.y += 1;
Vector2[] xzRoof = new Vector2[w.nodes.Count -1];
for (int a = 0; a < xzRoof.Length; a++)
{
xzRoof[a] = xz[a];
}
int[] indices;
Vector3[] roofNodes;
if (nodes.Length != 5 && nodes.Length != 6 && nodes.Length != 7 && nodes.Length != 8)
{
Triangulator tr = new Triangulator(xzRoof);
int[] tempIndices = tr.Triangulate();
indices = tempIndices;
roofNodes = nodes;
}
else
{
int[] tempIndices = new int[(nodes.Length-1)*3];
Vector3 midpoint = new Vector3();
for (int i = 0; i < nodes.Length-1; i++)
{
midpoint.x += nodes[i].x;
midpoint.y += nodes[i].y;
midpoint.z += nodes[i].z;
}
roofNodes = new Vector3[nodes.Length];
midpoint.x = midpoint.x / (nodes.Length-1);
midpoint.y = midpoint.y / (nodes.Length - 1) + height/5;
midpoint.z = midpoint.z / (nodes.Length - 1);
for (int i = 0; i < roofNodes.Length - 1; i++)
{
roofNodes[i] = nodes[i];
}
roofNodes[roofNodes.Length - 1] = midpoint;
Triangle test = new Triangle();
test.a = roofNodes[0];
test.b = roofNodes[1];
test.c = roofNodes[4];
Vector3 testVector = test.Normal;
int u = 0;
for (int i = 0; i < roofNodes.Length - 2; i += 1)
{
if (testVector.y > 0)
{
tempIndices[u] = i;
tempIndices[u + 1] = i + 1;
tempIndices[u + 2] = roofNodes.Length - 1;
}
else
{
tempIndices[u + 1] = i;
tempIndices[u] = i + 1;
tempIndices[u + 2] = roofNodes.Length - 1;
}
u += 3;
if (u >= tempIndices.Length - 3)
{
i += 1;
if (testVector.y > 0)
{
tempIndices[u] = i;
tempIndices[u + 1] = 0;
tempIndices[u + 2] = roofNodes.Length - 1;
}
else
{
tempIndices[u + 1] = i;
tempIndices[u] = 0;
tempIndices[u + 2] = roofNodes.Length - 1;
}
}
}
indices = tempIndices;
}
// Create the mesh
Vector2[] uvs = new Vector2[roofNodes.Length];
for (int a = 0; a < roofNodes.Length; a++)
{
if (a < roofNodes.Length - 1)
{
uvs[a] = new Vector2(a,0);
}
else
{
uvs[a] = new Vector2(a/2, 1);
}
}
roofm.vertices = roofNodes;
roofm.triangles = indices;
roofm.uv = uvs;
roofm.RecalculateNormals();
roofm.RecalculateBounds();
// Set up game object with mesh;
centroid = new Vector3(centroid.x, centroid.y, centroid.z);
wallsm = BuildingCountourMesh(nodes, wallsm, height);
if (w.name != null)
{
GameObject label = new GameObject();
FloatingLabel lb = label.AddComponent<FloatingLabel>();
lb.transform.parent = roof.transform;
lb.text = w.name;
lb.target = GameObject.FindGameObjectWithTag("Player").transform;
lb.transform.position = centroid;
}
build.transform.parent = mcl.transform;
walls.transform.parent = build.transform;
roof.transform.parent = build.transform;
//Wall
filter.sharedMesh = wallsm;
// wallmc.sharedMesh = wallsm;
//Roof
filter2.sharedMesh = roofm;
//roofmc.sharedMesh = roofm;
if (mcl.exportObjs)
{
ObjExporter oe1 = new ObjExporter();
ObjExporter oe2 = new ObjExporter();
oe1.MeshToFile(filter, buildPath);
oe2.MeshToFile(filter2, roofPath);
}
}
else
{
ObjImporter oi = new ObjImporter();
mcl.StartCoroutine(oi.FileToMesh("file://" + buildPath));
while (oi._myMesh == null)
{
yield return null;
}
filter.sharedMesh = oi._myMesh;
Debug.LogWarning("Loaded Walls from cache " + buildPath);
ObjImporter oi2 = new ObjImporter();
mcl.StartCoroutine(oi2.FileToMesh("file://" + roofPath));
while (oi2._myMesh == null)
{
yield return null;
}
filter2.sharedMesh = oi2._myMesh;
Debug.LogWarning("Loaded Roof from cache " + roofPath);
}
/*if (w.height != 0)
{
walls.GetComponent<MeshRenderer>().material = Resources.Load("Materials/Real Height Material") as Material;
}
else*/
{
int textureIndex = UnityEngine.Random.Range(1,4);
walls.GetComponent<MeshRenderer>().material = Resources.Load("Materials/BuildingMaterial" + textureIndex) as Material;
}
/*if (w.height != 0)
{
roof.GetComponent<MeshRenderer>().material = Resources.Load("Materials/Real Height Material") as Material;
}
else*/
{
int textureIndex = UnityEngine.Random.Range(1, 3);
roof.GetComponent<MeshRenderer>().material = Resources.Load("Materials/Roof" + textureIndex) as Material;
}
}
public static void SaveObjToDisk(MeshFilter meshFilter, string filePath)
{
ObjExporter.MeshToFile(meshFilter, filePath);
}
public override IEnumerator Build(Way w, MapChunkLoader mcl)
{
//GameObject go = new GameObject();
//go.name = "Road";
GameObject road = new GameObject();
road.name = "Road - " + w.id.ToString();
road.isStatic = true;
road.transform.parent = mcl.transform;
string roadPath = Application.persistentDataPath + "Assets/Resources/Objs/" + road.name + ".obj";
if (!File.Exists(roadPath)) // If the file isn't cached we calculate everything and then we cache it
{
Debug.Log("STARTED CREATING ROAD");
PolyLine pl = new PolyLine(w.id.ToString());
pl.SetOffset(mcl.offsetPositionX, mcl.offsetPositionZ);
pl.heigth = w.height;
if (w.type == WayType.Footway)
{
pl.material = Resources.Load("Materials/Footway Material") as Material;
pl.width = 1;
}
if (w.type == WayType.Motorway)
{
pl.material = Resources.Load("Materials/Road Material") as Material;
pl.width = 4;
pl.lanes = 2;
}
if (w.type == WayType.Residential)
{
pl.material = Resources.Load("Materials/Road Material") as Material;
pl.width = 2;
}
if (w.type == WayType.River)
{
pl.material = Resources.Load("Materials/River Material") as Material;
pl.width = 8;
}
for (int a = 0; a < w.nodes.Count; a++)
{
Node n = w.nodes[a];
Vector3 position = new Vector3((float)(n.easthing - mcl.offsetPositionX), 5000, (float)(n.northing - mcl.offsetPositionZ));
float baseHeight = 0;
RaycastHit hit;
if (Physics.Raycast(position, -Vector3.up, out hit, Mathf.Infinity, mcl.layerMask))
{
baseHeight = hit.point.y;
}
n.height = baseHeight;
pl.Add(n);
}
//Closed road;
mcl.StartCoroutine(pl.Close(road));
if (mcl.exportObjs)
{
while (road.GetComponent<MeshFilter>() == null)
{
yield return null;
}
MeshFilter mf = road.GetComponent<MeshFilter>();
ObjExporter oe = new ObjExporter();
oe.MeshToFile(mf, roadPath);
}
}
else
{
ObjImporter oi = new ObjImporter();
mcl.StartCoroutine(oi.FileToMesh("file://" + roadPath));
while (oi._myMesh == null)
{
yield return null;
}
MeshFilter mf = road.AddComponent<MeshFilter>();
MeshRenderer mr = road.AddComponent<MeshRenderer>();
mf.sharedMesh = oi._myMesh;
Debug.LogWarning("Loaded Road from cache " + roadPath);
if (w.type == WayType.Footway)
{
mr.material = Resources.Load("Materials/Footway Material") as Material;
}
if (w.type == WayType.Motorway)
{
mr.material = Resources.Load("Materials/Road Material") as Material;
}
if (w.type == WayType.Residential)
{
mr.material = Resources.Load("Materials/Road Material") as Material;
}
if (w.type == WayType.River)
{
mr.material = Resources.Load("Materials/River Material") as Material;
}
}
}
public override IEnumerator Build(Way w, MapChunkLoader mcl)
{
Vector3[] nodes = new Vector3[w.nodes.Count];
Vector2[] xz = new Vector2[w.nodes.Count];
float height = 0;
mcl.mapManager.mapHash.Add(w.id);
mcl.wayList.Add(w.id);
GameObject roof = new GameObject();
// roof.transform.position = new Vector3(0, centroid.y, 0);
roof.name = "Area - " + (2 * w.id).ToString();
mcl.mapManager.mapHash.Add(2 * w.id);
mcl.wayList.Add(2 * w.id);
roof.isStatic = true;
if (w.name != null)
{
GameObject label = new GameObject();
FloatingLabel lb = label.AddComponent<FloatingLabel>();
lb.text = w.name;
//lb.transform.position = centroid;
lb.target = GameObject.FindGameObjectWithTag("Player").transform;
label.transform.parent = roof.transform;
}
roof.transform.parent = mcl.transform;
Mesh roofm = new Mesh();
roof.AddComponent<MeshRenderer>();
MeshFilter filter2 = roof.AddComponent<MeshFilter>();
roof.AddComponent<MeshCollider>();
string areaPath = Application.persistentDataPath + "Assets/Resources/Objs/" + roof.name + ".obj";
if (!File.Exists(areaPath)) // If the file isn't cached we calculate everything and then we cache it
{
if (w.height != 0)
height = w.height;
Vector3 centroid = new Vector3();
for (int a = 0; a < w.nodes.Count; a++)
{
yield return null;
RaycastHit hit;
Node n = w.nodes[a];
nodes[a] = new Vector3((float)((n.easthing - mcl.offsetPositionX) / MapChunkLoader.precision), 5000, (float)((n.northing - mcl.offsetPositionZ) / MapChunkLoader.precision));
if (Physics.Raycast(nodes[a], -Vector3.up, out hit, Mathf.Infinity, mcl.layerMask))
{
nodes[a].y = hit.point.y + height + 0.5f;
}
else
{
nodes[a].y = 1;
}
xz[a] = new Vector2((float)((n.easthing - mcl.offsetPositionX) / MapChunkLoader.precision), (float)((n.northing - mcl.offsetPositionZ) / MapChunkLoader.precision));
centroid += nodes[a];
}
centroid /= w.nodes.Count;
centroid.y += 1;
// Vector3 position = new Vector3(centroid.x, 5000, centroid.z);
float baseHeight = 0;
/*RaycastHit hit;
if (Physics.Raycast(position, -Vector3.up, out hit, Mathf.Infinity, layerMask))
{
baseHeight = hit.point.y;
}*/
//centroid = new Vector3(centroid.x, centroid.y + baseHeight, centroid.z);
Vector2[] xzRoof = new Vector2[w.nodes.Count - 1];
for (int a = 0; a < xzRoof.Length; a++)
{
xzRoof[a] = xz[a];
}
Triangulator tr = new Triangulator(xzRoof);
int[] indices = tr.Triangulate();
// Create the mesh
roofm.vertices = nodes;
roofm.triangles = indices;
Vector2[] uvs = new Vector2[nodes.Length];
for (int a = 0; a < nodes.Length; a++)
{
if (a < nodes.Length - 1)
{
uvs[a] = new Vector2(Mathf.Abs(nodes[a].x) / nodes[nodes.Length - 1].x, Mathf.Abs(nodes[a].z) / nodes[nodes.Length - 1].x);
}
else
{
uvs[a] = new Vector2(1, 1);
}
}
roofm.uv = uvs;
roofm.RecalculateNormals();
roofm.RecalculateBounds();
filter2.sharedMesh = roofm;
if (mcl.exportObjs)
{
ObjExporter oe = new ObjExporter();
oe.MeshToFile(filter2, areaPath);
}
}
else
{
ObjImporter oi = new ObjImporter();
mcl.StartCoroutine(oi.FileToMesh("file://" + areaPath));
while (oi._myMesh == null)
{
yield return null;
}
filter2.sharedMesh = oi._myMesh;
Debug.LogWarning("Loaded Area from cache " + areaPath);
}
if (w.type == WayType.Parking)
roof.GetComponent<MeshRenderer>().material = Resources.Load("Materials/Parking Material") as Material;
if (w.type == WayType.Park)
roof.GetComponent<MeshRenderer>().material = Resources.Load("Materials/Park Material") as Material;
if (w.type == WayType.RiverBank)
roof.GetComponent<MeshRenderer>().material = Resources.Load("Materials/River Material") as Material;
}
public IEnumerator FusionSelection()
{
//Wait for object selection or cancel
while (fusionList.Count != 2 && this.FusionPanel.activeInHierarchy)
{
yield return(new WaitForSeconds(0.001f));
}
//Do merge
if (fusionList.Count == 2)
{
GameObject GO1 = GameObject.Find(fusionList.Keys[0]);
GameObject GO2 = GameObject.Find(fusionList.Keys[1]);
Debug.Log("MERGING " + GO1.name + " AND " + GO2.name);
if (GeomUtils.Intersects(GO1, GO2))
{
Debug.Log("INTERSECTS");
string GO1Off = ObjectFileFormat.MeshToOff(GO1.GetComponent <MeshFilter>().mesh, GO1.transform);
string GO2Off = ObjectFileFormat.MeshToOff(GO2.GetComponent <MeshFilter>().mesh, GO2.transform);
System.IntPtr GO1Ptr = Marshal.StringToHGlobalAnsi(GO1Off);
IntPtr GO2Ptr = Marshal.StringToHGlobalAnsi(GO2Off);
String matrix1 = GeomUtils.GetTransformationMatrix(GO1.transform, 0f, 0f, 0f);
String matrix2 = GeomUtils.GetTransformationMatrix(GO1.transform, 0f, 0f, 0f);
IntPtr GO1TransformPtr = Marshal.StringToHGlobalAnsi(matrix1);
IntPtr GO2TransformPtr = Marshal.StringToHGlobalAnsi(matrix2);
IntPtr ptrResult = CGALPlugin.BooleanOperationClean(GO1Ptr, GO1TransformPtr, GO2Ptr, GO2TransformPtr, Marshal.StringToHGlobalAnsi("union"));
string result = Marshal.PtrToStringAnsi(ptrResult);
//exportOff
/*StreamWriter SW = new StreamWriter(SceneManager.DataPath + "Fusion-" + DateTime.Now.ToString("hhmmss") + (Time.deltaTime * 1000) + ".off");
* SW.Write(result);
* SW.Close();*/
// Open string stream on the result off string
byte[] byteArray = Encoding.UTF8.GetBytes(result);
MemoryStream stream = new MemoryStream(byteArray);
//Convert off string to Mesh and add it to scene
Mesh myMesh = ObjectFileFormat.OffToMesh(new StreamReader(stream));
stream.Close();
myMesh.RecalculateNormals();
//Export obj file
ObjExporter.MeshToFile(myMesh, "Fusion-" + DateTime.Now.ToString("hhmmssffff"), "BenchMat");
//Add mesh to scene
GeomUtils.AddMeshToScene("Fusion-" + DateTime.Now.ToString("hhmmssffff"), myMesh, Vector3.zero, objectContainer.transform);
//Destroy previous previous meshes
Destroy(GO1.transform.parent.gameObject);
Destroy(GO2.transform.parent.gameObject);
}
//Not intersecting
else
{
SceneManager.instance.errorMesage.text = "Selected objects are not overlapped !";
}
ResetFusionSelection();
}
}
