void statusVertexNum()
{
MeshFilter[] primitives = GameObject.FindObjectsOfType <MeshFilter>() as MeshFilter[];
for (int i = 0; i < primitives.Length; ++i)
{
_vertexCount += MeshExporter.getMeshVertexCount(primitives[i]);
}
}
void OutputWholeScene()
{
MaterialExporter matEx = GetComponent <MaterialExporter>();
MeshExporter meshEx = GetComponent <MeshExporter>();
TextureExporter texEx = GetComponent <TextureExporter>();
Dictionary <Material, bool> matDict = new Dictionary <Material, bool>();
Dictionary <Mesh, bool> meshDict = new Dictionary <Mesh, bool>();
Dictionary <Texture2D, bool> texDict = new Dictionary <Texture2D, bool>();
GetSceneData(
SceneManager.GetActiveScene(),
meshDict, matDict, texDict);
void * jsonObjPtr = UnsafeUtility.Malloc((long)MJsonUtility.JsonObjectSize(), 16, Unity.Collections.Allocator.Temp);
string jsonPath = folder + "AssetDatabase.json";
fixed(char *c = jsonPath)
{
MJsonUtility.CreateJsonObject(c, (ulong)jsonPath.Length, jsonObjPtr);
}
List <Mesh> meshes = new List <Mesh>(meshDict.Count);
List <string> meshNames = new List <string>(meshDict.Count);
foreach (var i in meshDict)
{
string guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(i.Key));
string name = folder + i.Key.name + ".vmesh";
meshes.Add(i.Key);
meshNames.Add(name);
MJsonUtility.UpdateKeyValue(jsonObjPtr, guid.Ptr(), (ulong)guid.Length, name.Ptr(), (ulong)name.Length);
}
foreach (var i in matDict)
{
string guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(i.Key));
string name = folder + i.Key.name + ".mat";
MJsonUtility.UpdateKeyValue(jsonObjPtr, guid.Ptr(), (ulong)guid.Length, name.Ptr(), (ulong)name.Length);
matEx.testMat = i.Key;
matEx.PrintToFile(name);
}
foreach (var i in texDict)
{
string guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(i.Key));
string name = folder + i.Key.name + ".vtex";
MJsonUtility.UpdateKeyValue(jsonObjPtr, guid.Ptr(), (ulong)guid.Length, name.Ptr(), (ulong)name.Length);
texEx.texture = i.Key;
texEx.path = name;
texEx.useMipMap = true;
texEx.tex2DFormat = TextureData.LoadFormat.LoadFormat_BC7;
texEx.Print();
}
meshEx.ExportAllMeshes(meshes, meshNames);
MJsonUtility.OutputJsonObject(jsonPath.Ptr(), (ulong)jsonPath.Length, jsonObjPtr);
MJsonUtility.DisposeJsonObject(jsonObjPtr);
}
void Start()
{
var filter = gameObject.AddComponent <MeshFilter>();
filter.sharedMesh = CreateRegularTetrahedronMesh();
var renderer = gameObject.AddComponent <MeshRenderer>();
renderer.sharedMaterial = material;
if (exportMesh)
{
MeshExporter.Export(filter);
}
}
private void ExportMeshAndTexture()
{
var timestamp = DateTime.Now.ToString("MMM dd, yyyy - hh-mm-ss");
var localFolder = ApplicationData.Current.LocalFolder;
var newFolder = localFolder.CreateFolderAsync(timestamp).AsTask().Result;
var modelFile = newFolder.CreateFileAsync("Mesh.obj", CreationCollisionOption.ReplaceExisting).AsTask().Result;
FileIO.WriteTextAsync(modelFile, Meshes.ExportMesh("Material.mtl", "default")).AsTask().Wait(-1);
var materialFile = newFolder.CreateFileAsync("Material.mtl", CreationCollisionOption.ReplaceExisting).AsTask().Result;
FileIO.WriteTextAsync(materialFile, MeshExporter.GetMaterialFile("Texture.png")).AsTask().Wait(-1);
var textureFile = newFolder.CreateFileAsync("Texture.png", CreationCollisionOption.ReplaceExisting).AsTask().Result;
MeshExporter.ExportTexture(Resources, textureFile, MeshTexturer.MeshColorTexture);
}
public override void OnInspectorGUI()
{
MeshExporter exporter = target as MeshExporter;
DrawDefaultInspector();
GUILayout.BeginHorizontal();
if (GUILayout.Button("Convert"))
{
exporter.Export();
}
if (GUILayout.Button("Reset"))
{
exporter.datas = null;
}
GUILayout.EndHorizontal();
}
void handleChild(Transform node)
{
var mc = node.GetComponent <MeshComp>();
var prim = node.GetComponent <MeshFilter>();
var isActive = node.gameObject.activeInHierarchy;
if (mc && mc.isActiveAndEnabled && isActive)
{
// 单独导出网格文件
var shapeData = new JsonData();
shapeData["type"] = "triMesh";
shapeData["subType"] = "mesh";
var transformData = new JsonData();
transformData["type"] = "matrix";
transformData["param"] = Util.fromMatrix(node.localToWorldMatrix);
shapeData["transform"] = transformData;
shapeData["param"] = mc.fileName + "." + mc.extName();
if (_output["shapes"] == null)
{
_output["shapes"] = new JsonData();
}
_output["shapes"].Add(shapeData);
// 如果该节点包含MeshComp组件，则表示该节点单独导出文件
return;
}
else if (prim && isActive)
{
if (_output["shapes"] == null)
{
_output["shapes"] = new JsonData();
}
// 如果有prim对象并且处于激活状态
_output["shapes"].Add(MeshExporter.getPrimData(prim, transform, this));
}
foreach (Transform child in node.transform)
{
handleChild(child);
}
}
private void toolStripButton5_Click(object sender, EventArgs e)
{
int n = toolStripComboBox1.SelectedIndex;
string selectedSkeleton = null;
if (toolStripComboBox2.Enabled && toolStripComboBox2.SelectedIndex > 1)
{
selectedSkeleton = (string)toolStripComboBox2.SelectedItem;
}
ExportMeshSaveDialog emsd = new ExportMeshSaveDialog(mesh.lods.Count, 100f, false,
(mesh.header.type == MeshType.MeshType_Skinned), selectedSkeleton, n);
if (emsd.ShowDialog() == DialogResult.OK)
{
// we try to load the skeleton only if none was already selected for preview
// or if one was selected and it is different from the one selected in the option window
if (!skeletons.ContainsKey(toolStripComboBox2.SelectedItem.ToString()) ||
(skeletons.ContainsKey(toolStripComboBox2.SelectedItem.ToString()) &&
skeletons[toolStripComboBox2.SelectedItem.ToString()] != emsd.Skeleton))
{
string sha1 = emsd.Skeleton;
if (sha1 != null)
{
var sebx = new EBX(new MemoryStream(main.Host.getDataBySha1(Helpers.HexStringToByteArray(sha1))));
skeleton = new SkeletonAsset(sebx);
}
}
// scale
float aScale = emsd.ExportScale;
// get exporter by format
var exporter = MeshExporter.GetExporterByExtension(emsd.Format, skeleton);
if (exporter != null)
{
if (emsd.AllLod)
{
FolderBrowserDialog fbd = new FolderBrowserDialog();
fbd.Description = "Select folder where to save the lods";
if (fbd.ShowDialog() == DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
for (int i = 0; i < mesh.lods.Count; i++)
{
PrepareLodForExport(mesh, i);
}
exporter.ExportAllLods(mesh, fbd.SelectedPath, aScale);
MessageBox.Show("Done.");
Cursor.Current = Cursors.Default;
}
}
else
{
// lod
int sLod = emsd.Lod;
SaveFileDialog saveFileDiag = new SaveFileDialog();
saveFileDiag.Title = "Save as...";
saveFileDiag.Filter = "*" + emsd.Format + "|*" + emsd.Format;
saveFileDiag.FileName = mesh.lods[n].shortName;
if (saveFileDiag.ShowDialog() == DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
string targetFile = saveFileDiag.FileName;
PrepareLodForExport(mesh, sLod);
exporter.ExportLod(mesh, sLod, targetFile, aScale);
MessageBox.Show("Done.");
Cursor.Current = Cursors.Default;
}
}
}
else
{
MessageBox.Show("Unknown extension " + emsd.Format);
}
}
}
private void ExportAsset(object sender, RoutedEventArgs e)
{
var menu = sender as MenuItem;
var ctx = menu.DataContext as ExportItem;
string ext, name;
switch (ctx.Type)
{
case ExportType.JSON:
if (ExtraExports.Count == 0)
{
Helpers.AskConfirmation(this, "There isn't any JSON data to save", MessageBoxButton.OK);
return;
}
ext = "json";
name = "JSON File";
break;
case ExportType.IMAGE:
ext = "png";
name = "PNG Image";
break;
case ExportType.OPENGL:
ext = "psk";
name = "PSK File";
break;
case ExportType.INI:
ext = "ini";
name = "Ini File";
break;
case ExportType.RAW:
Helpers.AskConfirmation(this, "You can't export raw files. Use the \"Save As Raw\" button.", MessageBoxButton.OK);
return;
default:
// lol what
return;
}
var file = Helpers.ChooseSaveFile(name, ext);
if (file == null)
{
return;
}
switch (ctx.Type)
{
case ExportType.JSON:
File.WriteAllText(file, JsonTxt.Text);
break;
case ExportType.IMAGE:
using (var data = ((SKImage)ctx.Data).Encode())
using (var stream = data.AsStream())
using (var fStream = File.OpenWrite(file))
{
stream.CopyTo(fStream);
}
break;
case ExportType.OPENGL:
using (var fStream = File.OpenWrite(file))
using (var writer = new BinaryWriter(fStream))
{
var cSkel = new CSkeletalMesh((USkeletalMesh)ctx.Data);
MeshExporter.ExportMesh(writer, cSkel, cSkel.Lods[0]);
}
break;
case ExportType.INI:
File.WriteAllText(file, IniTxt.Text);
break;
default:
// lol what
return;
}
}
public override void OnInspectorGUI()
{
if (!IsReady())
{
InitializeEditor();
return;
}
MarchingTerrain terrain = (MarchingTerrain)target;
var configuration = (TerrainConfiguration)EditorGUILayout.ObjectField("Configuration", terrain.terrainConfiguration, typeof(TerrainConfiguration), false);
if (terrain.terrainConfiguration != configuration)
{
terrain.terrainConfiguration = configuration;
ProcessingUtility.StartProcessing(terrain.Rebuild());
}
if (terrain.terrainConfiguration != null)
{
var level = EditorGUILayout.IntField("Level", terrain.Level);
m_width = EditorGUILayout.IntField("Width", m_width);
m_height = EditorGUILayout.IntField("Height", m_height);
m_length = EditorGUILayout.IntField("Length", m_length);
m_terrainEditorUtility.currentProps.currentToolType = (ToolType)EditorGUILayout.EnumPopup("Tool", m_terrainEditorUtility.currentProps.currentToolType);
m_terrainEditorUtility.currentProps.brushRadius = EditorGUILayout.Slider("Radius", m_terrainEditorUtility.currentProps.brushRadius, 1, 25);
m_terrainEditorUtility.currentProps.brushOpacity = EditorGUILayout.Slider("Opacity", m_terrainEditorUtility.currentProps.brushOpacity, 0.001F, 1F);
if (m_terrainEditorUtility.currentProps.currentToolType == ToolType.Paint)
{
m_terrainEditorUtility.currentProps.color = EditorGUILayout.ColorField("Color", m_terrainEditorUtility.currentProps.color);
}
if (GUILayout.Button("Fill"))
{
terrain.terrainConfiguration.terrainMap.Fill(0, 0, 0, terrain.Width, terrain.Height - 1, terrain.Length, 1);
ProcessingUtility.StartProcessing(terrain.Rebuild());
}
level = Mathf.Clamp(level, 1, MarchingTerrain.m_chunkSize / 2);
if (terrain.Level != level)
{
terrain.Level = level;
ProcessingUtility.StartProcessing(terrain.SetLevel(level));
}
if (terrain.Width != m_width || terrain.Height != m_height || terrain.Length != m_length)
{
if (GUILayout.Button("Resize"))
{
terrain.terrainConfiguration.Resize(m_width, m_height, m_length);
ProcessingUtility.StartProcessing(terrain.Rebuild());
}
}
if (GUILayout.Button("Rebuild"))
{
ProcessingUtility.StartProcessing(terrain.Build());
}
if (GUILayout.Button("Export"))
{
Mesh mesh = ProcessingUtility.StartProcessing(terrain.BuildMesh()) as Mesh;
if (mesh != null)
{
string path = EditorUtility.SaveFilePanel("Exporting mesh", "Assets", "terrain", "obj");
MeshExporter.MeshToFile(mesh, path);
}
}
if (GUILayout.Button("Save"))
{
terrain.terrainConfiguration.Save();
}
}
}
public bool ExportScene(string fileName, List <string> zmsFileNames)
{
int idx = 1;
try
{
StreamWriter fileStream = new StreamWriter(fileName);
//List<string> animationNames = new List<string>();
//foreach (string fname in zmoFileNames)
//{
// animationNames.Add(Path.GetFileNameWithoutExtension(fname));
//}
List <string> meshNames = new List <string>();
foreach (string fname in zmsFileNames)
{
meshNames.Add(Path.GetFileNameWithoutExtension(fname));
}
MeshExporter meshExporter = new MeshExporter(idx, zms, meshNames, zmd.BonesCount > 0);
idx = meshExporter.LastResourceIndex;
scene.AppendLine(meshExporter.Resources);
AnimationExporter animExporter = new AnimationExporter(idx, zmo, zmd);
// meshes & bone weights
idx = animExporter.LastResourceIndex;
// animations
// normalize the rotation quats!
if (zmo.Count > 0)
{
scene.AppendLine(animExporter.Resources);
idx = animExporter.LastResourceIndex;
}
scene.AppendLine("; scene root node");
scene.AppendFormat("[node type=\"Spatial\" name=\"{0}\"]\n", objName);
scene.AppendLine("transform = Transform(1, 0, 0, 0, 0, 1, 0, -1, 0, 0, 0, 0)\n");
// skeleton
if (zmd.BonesCount > 0)
{
BoneExporter boneExporter = new BoneExporter(idx, zmd);
scene.AppendLine(boneExporter.ToString());
idx = animExporter.LastResourceIndex;
}
scene.AppendLine(meshExporter.Nodes);
if (zmo.Count > 0)
{
scene.AppendLine(animExporter.Nodes);
}
fileStream.WriteLine(scene);
fileStream.Close();
return(true);
}
catch (Exception x)
{
// log?
Console.WriteLine(x.Message);
return(false);
}
}
private void toolStripButton5_Click(object sender, EventArgs e)
{
int n = toolStripComboBox1.SelectedIndex;
byte[] id = mesh.lods[n].chunkID;
string sid = Helpers.ByteArrayToHexString(id);
rawLodBuffer = null;
hb2.ByteProvider = new DynamicByteProvider(new byte[0]);
foreach (ChunkInfo chunk in chunks)
{
if (chunk.id == sid)
{
rawLodBuffer = main.Host.getDataBySha1(chunk.sha1);
hb2.ByteProvider = new DynamicByteProvider(rawLodBuffer);
break;
}
}
if (rawLodBuffer == null)
{
foreach (ChunkInfo chunk in tocChunks[currToc])
{
if (chunk.id == sid)
{
rawLodBuffer = main.Host.getDataBySha1(chunk.sha1);
hb2.ByteProvider = new DynamicByteProvider(rawLodBuffer);
return;
}
}
}
if (rawLodBuffer != null)
{
mesh.lods[n].LoadVertexData(new MemoryStream(rawLodBuffer));
if (flipUToolStripMenuItem.Checked || flipVToolStripMenuItem.Checked)
{
for (int i = 0; i < mesh.lods[n].sections.Count; i++)
{
MeshLodSection sec = mesh.lods[n].sections[i];
for (int j = 0; j < sec.vertices.Count; j++)
{
if (sec.vertices[i].texCoords.members.Length == 2)
{
if (flipUToolStripMenuItem.Checked)
{
sec.vertices[i].texCoords.members[0] = 1 - sec.vertices[i].texCoords.members[0];
}
if (flipVToolStripMenuItem.Checked)
{
sec.vertices[i].texCoords.members[1] = 1 - sec.vertices[i].texCoords.members[1];
}
}
}
mesh.lods[n].sections[i] = sec;
}
}
SaveFileDialog saveFileDiag = new SaveFileDialog();
saveFileDiag.Title = "Save as...";
saveFileDiag.Filter = "*.obj|*.obj|*.psk|*.psk|*.fbx|*.fbx";
saveFileDiag.FileName = mesh.header.shortName;
if (saveFileDiag.ShowDialog() == DialogResult.OK)
{
string extension = Path.GetExtension(saveFileDiag.FileName);
string targetFile = saveFileDiag.FileName;
var exporter = MeshExporter.GetExporterByExtension(extension, skeleton);
if (exporter != null)
{
exporter.ExportLod(mesh, n, targetFile);
MessageBox.Show("Done.");
}
else
{
MessageBox.Show("Unknown extension " + extension);
}
}
}
}
private void ExportMeshWorker_DoWork(object sender, DoWorkEventArgs e)
{
exportMeshes = MeshExporter.ExportMeshes(new Progress <ProgressUpdate>(SetProgress), robotDataManager.RobotBaseNode, robotDataManager.RobotWeightKg, ExportMeshWorker);
}
// export selected morph :
// search for base mesh and applies selected morph deformation to it and to selected skeleton and exports the result.
private void exportMorphToolStripMenuItem_Click(object sender, EventArgs e)
{
if (rawEbxBuffer != null && rawResBuffer != null)
{
string morphName = Path.GetFileName(currPath);
var morph = new MorphStaticExtended(new MemoryStream(rawResBuffer), new MemoryStream(rawEbxBuffer), morphName);
ExportMeshSaveDialog emd = new ExportMeshSaveDialog(morph.LodCount, 100f, true);
if (emd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
// look for preset Mesh
DataInfo presetMeshRes = SearchItemRES(morph.PresetMesh);
if (presetMeshRes != null)
{
byte[] meshData = main.Host.getDataBySha1(presetMeshRes.sha1);
MeshAsset presetMeshAsset = new MeshAsset(new MemoryStream(meshData));
SkeletonAsset skeleton = null;
int lod = emd.Lod;
string sha1 = emd.Skeleton;
if (sha1 != null)
{
var sebx = new EBX(new MemoryStream(main.Host.getDataBySha1(Helpers.HexStringToByteArray(sha1))));
skeleton = new SkeletonAsset(sebx);
}
float oScale = emd.ExportScale;
bool bakeMorphToMesh = emd.BakeMorph;
string ext = emd.Format;
IMeshExporter exporter = MeshExporter.GetExporterByExtension(ext, skeleton);
Cursor.Current = Cursors.Default;
if (emd.AllLod)
{
FolderBrowserDialog fbd = new FolderBrowserDialog();
fbd.Description = "Select folder where to save all LODS...";
if (fbd.ShowDialog() == DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
for (int i = 0; i < morph.LodCount; i++)
{
ChunkInfo lodChunk = SearchChunk(Helpers.ByteArrayToHexString(presetMeshAsset.lods[i].chunkID));
if (lodChunk != null)
{
byte[] rawChunkBuffer = main.Host.getDataBySha1(lodChunk.sha1);
presetMeshAsset.lods[i].LoadVertexData(new MemoryStream(rawChunkBuffer));
}
}
exporter.ExportAllLodsWithMorph(presetMeshAsset, morph, fbd.SelectedPath, oScale, bakeMorphToMesh);
MessageBox.Show("Done.");
Cursor.Current = Cursors.Default;
}
}
else
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Title = "Save Morph as...";
sfd.Filter = "*" + ext + "|*" + ext;
sfd.FileName = Path.GetFileName(currPath) + ext;
if (sfd.ShowDialog() == DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
ChunkInfo lodChunk = SearchChunk(Helpers.ByteArrayToHexString(presetMeshAsset.lods[lod].chunkID));
if (lodChunk != null)
{
byte[] rawChunkBuffer = main.Host.getDataBySha1(lodChunk.sha1);
presetMeshAsset.lods[lod].LoadVertexData(new MemoryStream(rawChunkBuffer));
exporter.ExportLodWithMorph(presetMeshAsset, lod, morph, sfd.FileName, oScale, bakeMorphToMesh);
MessageBox.Show("Done.");
Cursor.Current = Cursors.Default;
}
else
{
MessageBox.Show("Error : chunk for this lod was not found");
}
}
}
Cursor.Current = Cursors.Default;
}
else
{
MessageBox.Show("Error : Res data corresponding to preset mesh " + morph.PresetMesh + " not found.");
}
}
}
}
public void ExportMesh()
{
GameObject[] go = new GameObject[1];
go[0] = latelyCreatedObject;
MeshExporter.ExportGameObjects(go, settingsInputField.text);
}
