private void PrepareLodForExport(MeshAsset mesh, int n)
{
LoadRawLodBuffer(mesh, n);
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++)
{
for (int uvInd = 0; uvInd < Vertex.UV_SLOTS; uvInd++)
{
if (sec.vertices[i].texCoords[uvInd].members.Length == 2)
{
if (flipUToolStripMenuItem.Checked)
{
sec.vertices[i].texCoords[uvInd].members[0] = 1 - sec.vertices[i].texCoords[uvInd].members[0];
}
if (flipVToolStripMenuItem.Checked)
{
sec.vertices[i].texCoords[uvInd].members[1] = 1 - sec.vertices[i].texCoords[uvInd].members[1];
}
}
}
}
mesh.lods[n].sections[i] = sec;
}
}
}
}
//see ToolEvents\AssetMetadata.fs for metadata file format
List <MeshAsset> loadMeshes()
{
var meshes = new List <MeshAsset>();
if (!Directory.Exists(metadataPath + "Meshes"))
{
Directory.CreateDirectory(metadataPath + "Meshes");
}
foreach (var filename in Directory.EnumerateFiles(metadataPath + "Meshes"))
{
var metadata = File.ReadAllLines(filename);
var mesh = new MeshAsset();
mesh.Name = System.IO.Path.GetFileNameWithoutExtension(filename);
mesh.Description = metadata[0].Split('=')[1].Trim();
mesh.VertexFormat = metadata[1].Split('=')[1].Trim();
mesh.LastUpdated = parseLastUpdatedDate(metadata[2].Split('=')[1].Trim(), "mesh", mesh.Name);
mesh.SourceFilename = metadata[3].Split('=')[1].Trim();
mesh.Topology = (Topology)Enum.Parse(typeof(Topology), metadata[4].Split('=')[1].Trim());
mesh.ImportedFilename = metadata[5].Split('=')[1].Trim();
mesh.ImporterVersion = int.Parse(metadata[6].Split('=')[1].Trim());
meshes.Add(mesh);
}
return(meshes);
}
public void LoadMesh(byte[] sha1res, byte[] sha1ebx, string path)
{
rtb2.Text = "";
currPath = path;
tv3.Nodes.Clear();
rawResBuffer = main.Host.getDataBySha1(sha1res);
rawEbxBuffer = main.Host.getDataBySha1(sha1ebx);
if (rawEbxBuffer == null || rawResBuffer == null)
{
return;
}
try
{
hb1.ByteProvider = new DynamicByteProvider(rawResBuffer);
hb2.ByteProvider = new DynamicByteProvider(new byte[0]);
mesh = new MeshAsset(new MemoryStream(rawResBuffer));
rtb2.Text = mesh.ToString();
toolStripComboBox1.Items.Clear();
for (int i = 0; i < mesh.lods.Count; i++)
{
toolStripComboBox1.Items.Add("LOD " + i);
}
if (mesh.lods.Count > 0)
{
toolStripComboBox1.SelectedIndex = 0;
}
ebxObject = new EBX(new MemoryStream(rawEbxBuffer));
tv3.Nodes.Add(ebxObject.ToNode());
}
catch (Exception ex)
{
rtb2.Text = "ERROR!!!:\n" + ex.Message + "\n\n" + rtb2.Text;
}
}
public static void Save(this MeshAsset mesh, string path)
{
using (var stream = File.OpenWrite(path))
using (var sw = new BinaryWriter(stream))
{
var header = mesh.WriterHeader(sw);
var geomerty_header = mesh.WriterGeomerty(sw);
}
}
protected void WaitMeshLoadUpdate(float deltaTime)
{
if (MeshAsset != null && MeshAsset.GetAsset().IsLoaded)
{
SetPhysicsFromLoadedMesh();
m_loadWaitUpdateScope.Disconnect();
m_loadWaitUpdateScope = null;
}
}
public void CombineRender(MeshAsset oOtherAsset)
{
if (this.oSelfAsset == null)
{
return;
}
if (this.matchMono is SkinMeshLoader)
{
SkinnedMeshRenderer component = base.GetComponent <SkinnedMeshRenderer>();
if (component != null)
{
component.material = this.oSelfAsset.material;
component.sharedMesh = oOtherAsset.mesh;
GameObjectUnit.ChangeShader(component);
}
}
else if (this.matchMono is MeshLoader)
{
MeshRenderer component2 = base.GetComponent <MeshRenderer>();
if (component2 != null)
{
component2.material = this.oSelfAsset.material;
GameObjectUnit.ChangeShader(component2);
}
MeshFilter component3 = base.GetComponent <MeshFilter>();
if (component3 != null)
{
component3.mesh = oOtherAsset.mesh;
}
}
else if (this.matchMono == null)
{
MeshRenderer component4 = base.GetComponent <MeshRenderer>();
if (component4 != null)
{
component4.material = this.oSelfAsset.material;
GameObjectUnit.ChangeShader(component4);
}
else
{
SkinnedMeshRenderer component5 = base.GetComponent <SkinnedMeshRenderer>();
if (component5 != null)
{
component5.material = this.oSelfAsset.material;
GameObjectUnit.ChangeShader(component5);
}
}
}
if (this.matchMono != null)
{
UnityEngine.Object.Destroy(this.matchMono);
}
UnityEngine.Object.Destroy(this);
}
protected override Asset getOrCreateResourceRefObj(string name)
{
var lname = name.toLower();
Asset res = null;
if (!assets.TryGetValue(lname, out res))
{
res = new MeshAsset(this, lname);
assets[lname] = res;
}
return(res);
}
public override void Init()
{
base.Init();
if (MeshAsset == null || MeshAsset.GetAsset() == null || !MeshAsset.GetAsset().IsLoaded)
{
m_physicsMesh = new InstancedMesh(PhysicsStatics.DummyInstancedMesh);
m_physicsMesh.Sidedness = TriangleSidedness.Clockwise;
}
InvalidateCollider();
m_transform.OnPositionChanged += OnPositionChanged;
m_transform.OnRotationChanged += OnRotationChanged;
}
static Tuple <SectionCommonHeader, GeomertySectionHeader> WriterGeomerty(this MeshAsset mesh, BinaryWriter sw)
{
SectionCommonHeader common_header = new SectionCommonHeader();
GeomertySectionHeader geometry_header = new GeomertySectionHeader();
var common_offset = sw.Seek(0, SeekOrigin.Current);
common_header.SectionIndex = 0;
common_header.NextSectionOffset = uint.MaxValue;
common_header.Name = new byte[] {
(byte)'G', (byte)'E', (byte)'O', (byte)'M',
(byte)'E', (byte)'R', (byte)'T', (byte)'Y',
};
common_header.Size = uint.MaxValue;
//先写入用于计算大小
sw.Write(common_header.SectionIndex);
sw.Write(common_header.NextSectionOffset);
sw.Write(common_header.Name);
sw.Write(common_header.Size);
geometry_header.FourCC = FourCC.Value('L', 'E', 'M', 'E');
geometry_header.Version = 0;
geometry_header.CompressVersion = 0;
geometry_header.SizeOfOptional = 0;
sw.Write(geometry_header.FourCC);
sw.Write(geometry_header.Version);
sw.Write(geometry_header.CompressVersion);
sw.Write(geometry_header.SizeOfOptional);
//取得头写入完后的Offset
var data_offset = sw.Seek(0, SeekOrigin.Current);
var data_size = mesh.WrtieGeometryData(sw);
//Size包含头部大小
common_header.Size = (uint)(data_offset - common_offset + data_size);
//相对Origin的偏移
common_header.NextSectionOffset = (uint)(data_offset + data_size);
//重新写入头
sw.Seek((int)common_offset, SeekOrigin.Begin);
sw.Write(common_header.SectionIndex);
sw.Write(common_header.NextSectionOffset);
sw.Write(common_header.Name);
sw.Write(common_header.Size);
//跳到下一个Section
sw.Seek((int)common_header.NextSectionOffset, SeekOrigin.Begin);
return(Tuple.Create(common_header, geometry_header));
}
static internal void createMeshMetadata(MeshAsset mesh)
{
var metadata = new StringBuilder();
metadata.AppendLine("Description= " + mesh.Description)
.AppendLine("VertexFormat= " + mesh.VertexFormat)
.AppendLine("LastUpdated= " + mesh.LastUpdated.ToString("o"))
.AppendLine("SourceFilename= " + mesh.SourceFilename)
.AppendLine("Topology= " + mesh.Topology.ToString())
.AppendLine("ImportedFilename= " + mesh.ImportedFilename)
.AppendLine("ImporterVersion= " + mesh.ImporterVersion);
File.WriteAllText(MetadataPath + "Meshes/" + mesh.Name + ".meta", metadata.ToString());
}
static MeshHeader WriterHeader(this MeshAsset mesh, BinaryWriter sw)
{
MeshHeader header = new MeshHeader();
header.Signature = FourCC.Value('M', 'E', 'S', 'H');
header.Machine = 0;
header.NumberOfSections = 1;
header.SizeOfOptional = 0;
sw.Write(header.Signature);
sw.Write(header.Machine);
sw.Write(header.NumberOfSections);
sw.Write(header.SizeOfOptional);
return(header);
}
static public ModelGeometry LoadMesh(string assetName)
{
if (CachedMeshes.ContainsKey(assetName))
{
return(CachedMeshes[assetName]);
}
MeshAsset MA = AssetsManagerInstance.GetManager().LoadAsset <MeshAsset>(assetName);
ModelGeometry MG = new ModelGeometry(MA.FileScale, MA.Pivot, MA.Vertices, MA.Indexes, MA.BoundingMinimum, MA.BoundingMaximum);
MA = null;
CachedMeshes.Add(assetName, MG);
Debug.Log("AssetManager", "Mesh " + assetName + " loaded.");
return(MG);
}
private IEnumerator LoadMesh(MeshAsset modAsset, string objectPath)
{
var mesh = _objImporter.ImportFile(objectPath);
if (mesh == null)
{
_console.WriteLine("Mesh is null");
}
var meshFilter = modAsset.AddComponent <MeshFilter>();
meshFilter.mesh = mesh;
yield return(new WaitForEndOfFrame());
modAsset.SetAsset(meshFilter);
}
protected override void InvalidateCollider()
{
if (MeshAsset != null && MeshAsset.GetAsset() != null)
{
if (MeshAsset.GetAsset().IsLoaded)
{
SetPhysicsFromLoadedMesh();
}
else if (m_loadWaitUpdateScope == null)
{
m_loadWaitUpdateScope = World.UpdateScheduler.Connect(WaitMeshLoadUpdate, EUpdatePriority.Earliest);
}
}
else
{
m_physicsMesh.Shape = PhysicsStatics.DummyInstancedMesh;
}
}
/// <summary>
/// Load raw lod buffer of given mesh for given lod
/// For skeletal meshes : load vertices info from chunk after looking for chunk file
/// For rigid meshes : load vertices info from data in res buffer
/// </summary>
/// <param name="mesh">mesh for which we want to load vertices info.</param>
/// <param name="selectedLod">lod to load info for.</param>
private void LoadRawLodBuffer(MeshAsset mesh, int selectedLod)
{
byte[] id = mesh.lods[selectedLod].chunkID;
string sid = Helpers.ByteArrayToHexString(id);
rawLodBuffer = null;
// if this lod has a chunk id (skinned mesh case)
if (sid != "00000000000000000000000000000000")
{
// then the raw lod buffer will be a chunk : we look for it.
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);
break;
}
}
}
}
else
{
// when there is no chunk id, the info is in the res buffer itself (rigid meshes case)
MemoryStream str = new MemoryStream(rawResBuffer);
str.Seek(mesh.lods[selectedLod].InnerDataOffset, SeekOrigin.Begin);
int countb = (int)(mesh.lods[selectedLod].vertexDataSize + mesh.lods[selectedLod].indexDataSize);
rawLodBuffer = new byte[countb];
str.Read(rawLodBuffer, 0, countb);
}
}
public override void Start()
{
if (Mesh != null)
{
MeshAsset mergedMesh = Mesh.Merged;
Vector3f[] positions = mergedMesh.VerticesPositions;
Vector3f[] collection = new Vector3f[positions.Length];
Transform t = gameElement.WorldTransform;
for (int i = 0, l = positions.Length; i < l; i++)
{
// TODO: Transform positions here !!
collection[i] = positions[i];
}
Vector3f center;
_shape = new MobileMeshShape(collection, mergedMesh.Indices, new AffineTransform(t.Scale, Quaternion.FromEulerAngles(t.Rotation.Z, t.Rotation.Y, t.Rotation.X), t.Translation), MobileMeshSolidity.DoubleSided, out center);
_centerOffset = (Vector3f)center;
}
}
public bool ImportAsset(string Path, string Name, bool Rewrite, out BaseAsset assetRes)
{
string[] arr = Path.Split('.');
string ext = arr[arr.Length - 1].ToLower();
assetRes = null;
BaseAsset asset;
if (shaderExts.Contains(ext))
{
return(ImportShaderAsset(Path, Name, null, null, true, out assetRes));
}
else if (meshExts.Contains(ext))
{
asset = new MeshAsset()
{
Name = Name,
};
}
else if (textureExts.Contains(ext))
{
asset = new Texture2DAsset()
{
Name = Name,
// Hack for forcing srgb image with wrong meta-data
ForceSRgb = Name.Contains("Albedo"),
};
}
else
{
Console.WriteLine("Unknown asset extension: {0}", ext);
return(false);
}
if (!asset.ImportAsset(Path, ext))
{
return(false);
}
assetRes = asset;
return(FSWorker.CreateAssetFile(asset, Rewrite || asset.Type == AssetTypes.Shader));
}
public static void BuildMeshAssetFromPrefab(MenuCommand menuCommand)
{
Object activeObject = Selection.activeObject;
if (activeObject.GetType() != typeof(GameObject))
{
Debug.LogWarning("select asset is not Prefab");
return;
}
bool buildOK = false;
GameObject prefab = (GameObject)activeObject;
if (prefab.GetComponent <LODGroup>() == null)
{
buildOK = true;
}
if (prefab.GetComponent <MeshFilter>() == null || prefab.GetComponent <MeshRenderer>() == null)
{
buildOK = true;
}
if (buildOK)
{
MeshAsset meshAsset = ScriptableObject.CreateInstance <MeshAsset>();
meshAsset.target = prefab;
MeshAsset.BuildMeshAsset(prefab, meshAsset);
CreateMeshAsset meshAssetFactory = ScriptableObject.CreateInstance <CreateMeshAsset>();
meshAssetFactory.meshAsset = meshAsset;
ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, meshAssetFactory, "SM_" + prefab.name + ".asset", null, null);
}
else
{
Debug.LogWarning("select prefab doesn't have LODGroup or MeshRenderer");
}
}
public void SyncLoadPrefabMesh(List <PrefabRenderHolder.RenderMeshPair> rendersMeshInfos, List <Asset> meshResRefs)
{
if (rendersMeshInfos == null)
{
return;
}
int len = rendersMeshInfos.Count;
for (int i = 0; i < len; i++)
{
if (rendersMeshInfos[i].meshFilterObj == null)
{
continue;
}
MeshAsset res = (MeshAsset)MeshAssetManager.Singleton.Load(rendersMeshInfos[i].meshName);
rendersMeshInfos[i].meshFilterObj.sharedMesh = res.GetMainAsset() as Mesh;
res.AddRef();
//记录加载了哪些贴图
meshResRefs.Add(res);
}
}
private void OnFileLoaded(params object[] args)
{
MeshAsset x = args[0] as MeshAsset;
if (x == null)
{
return;
}
this.oSelfAsset = x;
if (this.matchMono != null)
{
this.matchMono.CombineRender(this.oSelfAsset);
}
else
{
SkinnedMeshRenderer component = base.GetComponent <SkinnedMeshRenderer>();
if (component != null)
{
component.sharedMesh = this.oSelfAsset.mesh;
}
}
}
public static BoundingBox CreateFromPoints(MeshAsset mesh)
{
return(CreateFromPoints(mesh.Merged.VerticesPositions));
}
MeshAsset IUnityMeshConvert.Convert(string path)
{
var mesh = new MeshAsset();
var unity_mesh = JObject.Parse(File.ReadAllText(path));
var vertices = ((JArray)unity_mesh["vertices"]).ToObject <float3[]>();
using (var stream = new MemoryStream())
using (var bw = new BinaryWriter(stream))
{
foreach (var vertex in vertices)
{
bw.Write(vertex.x);
bw.Write(vertex.y);
bw.Write(vertex.z);
}
bw.Flush();
var pos_element = new leo.Platform.Render.Vertex.Element();
pos_element.Format = EFormat.EF_BGR32F;
pos_element.Usage = leo.Platform.Render.Vertex.Usage.Position;
pos_element.UsageIndex = 0;
mesh.AddVertexStream(pos_element, stream.ToArray());
}
var normals = ((JArray)unity_mesh["normals"]).ToObject <float3[]>();
using (var stream = new MemoryStream())
using (var bw = new BinaryWriter(stream))
{
foreach (var normal in normals)
{
bw.Write(normal.x);
bw.Write(normal.y);
bw.Write(normal.z);
}
bw.Flush();
var normal_element = new leo.Platform.Render.Vertex.Element();
normal_element.Format = EFormat.EF_BGR32F;
normal_element.Usage = leo.Platform.Render.Vertex.Usage.Normal;
normal_element.UsageIndex = 0;
mesh.AddVertexStream(normal_element, stream.ToArray());
}
var triangles = ((JArray)unity_mesh["triangles"]).ToObject <uint[]>();
var index_format = EFormat.EF_R16UI;
if (triangles.Length > short.MaxValue)
{
index_format = EFormat.EF_R32UI;
}
var use_16 = index_format == EFormat.EF_R16UI;
using (var stream = new MemoryStream())
using (var bw = new BinaryWriter(stream))
{
foreach (var index in triangles)
{
if (use_16)
{
bw.Write((ushort)index);
}
else
{
bw.Write(index);
}
}
bw.Flush();
mesh.SetIndexStream(index_format, stream.ToArray());
}
mesh.IndexCount = (uint)triangles.Length;
mesh.VertexCount = (uint)vertices.Length;
var submesh = new MeshAsset.SubMeshDescrption()
{
MaterialIndex = 0,
};
submesh.AddLodDesciption(new MeshAsset.SubMeshDescrption.LodDescription()
{
IndexBase = 0,
IndexNum = mesh.IndexCount,
VertexBase = 0,
VertexNum = mesh.VertexCount
});
mesh.AddSubMeshDescrption(submesh);
return(mesh);
}
static void ConvertToMeshAnimationAsset(string path)
{
System.Type submoduleType;
submoduleType = SubmoduleMapEditorAdaptor.GetSubmoduleType(path);
if (submoduleType == null)
{
return;
}
string submodulePath;
submodulePath = SubmoduleMapEditorAdaptor.GetSubmodulePath(submoduleType);
if (string.IsNullOrEmpty(submodulePath))
{
return;
}
TextAsset asset;
asset = AssetDatabase.LoadAssetAtPath(path, typeof(TextAsset)) as TextAsset;
if (asset == null)
{
return;
}
XmlDocument document;
document = new XmlDocument();
try {
document.LoadXml(asset.text);
} catch {
return;
}
XmlNode animationsNode;
animationsNode = document.SelectSingleNode("/plist/dict/key[text() = 'animations']/following-sibling::dict");
if (animationsNode == null)
{
return;
}
XmlNode anchorPointNode;
anchorPointNode = document.SelectSingleNode("/plist/dict/key[text() = 'anchorPoint']/following-sibling::string");
Vector2 anchorPoint;
anchorPoint = ConvertToVector2(anchorPointNode);
XmlNode contentSizeNode;
contentSizeNode = document.SelectSingleNode("/plist/dict/key[text() = 'contentSize']/following-sibling::string");
Vector2 contentSize;
contentSize = ConvertToVector2(contentSizeNode);
foreach (XmlNode keyNode in animationsNode.SelectNodes("key"))
{
XmlNode dictNode;
dictNode = keyNode.NextSibling;
XmlNode delayNode;
delayNode = dictNode.SelectSingleNode("key[text() = 'delay']/following-sibling::real");
XmlNodeList stringNodes;
stringNodes = dictNode.SelectNodes("key[text() = 'frames']/following-sibling::array/string");
float interval;
interval = System.Convert.ToSingle(delayNode.InnerText);
float duration;
duration = interval * stringNodes.Count;
MeshAsset[] meshes;
meshes = new MeshAsset[stringNodes.Count];
for (int index = 0; index < stringNodes.Count; index++)
{
string meshPath;
meshPath = null;
MeshAsset mesh;
mesh = null;
if (!mesh)
{
meshPath = string.Format("{0}/_Resources_/Meshes/{1}.asset", submodulePath, Path.GetFileNameWithoutExtension(stringNodes.Item(index).InnerText));
mesh = AssetDatabase.LoadAssetAtPath(meshPath, typeof(MeshAsset)) as MeshAsset;
}
if (!mesh && meshes.Length == 1)
{
meshPath = string.Format("{0}/Resources/Meshes/{1}_0001.asset", submodulePath, Path.GetFileNameWithoutExtension(stringNodes.Item(index).InnerText));
mesh = AssetDatabase.LoadAssetAtPath(meshPath, typeof(MeshAsset)) as MeshAsset;
}
if (!mesh)
{
meshPath = string.Format("{0}/Meshes/{1}.asset", submodulePath, Path.GetFileNameWithoutExtension(stringNodes.Item(index).InnerText));
mesh = AssetDatabase.LoadAssetAtPath(meshPath, typeof(MeshAsset)) as MeshAsset;
}
if (!mesh && meshes.Length == 1)
{
meshPath = string.Format("{0}/Meshes/{1}_0001.asset", submodulePath, Path.GetFileNameWithoutExtension(stringNodes.Item(index).InnerText));
mesh = AssetDatabase.LoadAssetAtPath(meshPath, typeof(MeshAsset)) as MeshAsset;
}
if (!mesh)
{
EditorUtility.ClearProgressBar();
throw new System.Exception(string.Format("Cannot load mesh asset: {0}, {1}, {2}",
stringNodes.Item(index).InnerText,
string.Format("{0}/Meshes/{1}.asset", submodulePath, Path.GetFileNameWithoutExtension(stringNodes.Item(index).InnerText)),
string.Format("{0}/Meshes/{1}_0001.asset", submodulePath, Path.GetFileNameWithoutExtension(stringNodes.Item(index).InnerText))
));
}
meshes[index] = mesh;
}
string animationAssetPath;
animationAssetPath = string.Format("{0}/MeshAnimations/{1}.asset", submodulePath, keyNode.InnerText);
string animationResourcePath;
animationResourcePath = string.Format("{0}/_Resources_/MeshAnimations/{1}.asset", submodulePath, keyNode.InnerText);
MeshAnimationAsset existingAsset;
existingAsset = (
AssetDatabase.LoadAssetAtPath(animationResourcePath, typeof(MeshAnimationAsset)) as MeshAnimationAsset ??
AssetDatabase.LoadAssetAtPath(animationAssetPath, typeof(MeshAnimationAsset)) as MeshAnimationAsset
);
MeshAnimationAsset animationAsset;
animationAsset = ScriptableObject.CreateInstance <MeshAnimationAsset>();
animationAsset.name = keyNode.InnerText;
animationAsset.AnchorPoint = anchorPoint;
animationAsset.Audio = existingAsset ? existingAsset.Audio : null;
animationAsset.ContentSize = contentSize;
animationAsset.Duration = duration;
animationAsset.Meshes = meshes;
animationAsset.RecalculateBounds();
animationAsset.RecalculateCrop();
if (existingAsset)
{
EditorUtility.CopySerialized(animationAsset, existingAsset);
AssetDatabase.SaveAssets();
}
else
{
// create folder
if (!Directory.Exists(Path.GetDirectoryName(animationAssetPath)))
{
AssetDatabase.CreateFolder(
Path.GetDirectoryName(Path.GetDirectoryName(animationAssetPath)),
Path.GetFileName(Path.GetDirectoryName(animationAssetPath))
);
}
AssetDatabase.CreateAsset(animationAsset, animationAssetPath);
AssetDatabase.SaveAssets();
}
}
if (SagoMeshEditor.EditorSettings.Instance.DeleteIntermediateFiles)
{
AssetDatabase.DeleteAsset(path);
}
AssetDatabase.SaveAssets();
}
static internal void deleteMeshMetadata(MeshAsset mesh)
{
deleteMetadata(mesh, "Meshes/");
}
static long WrtieGeometryData(this MeshAsset mesh, BinaryWriter sw)
{
var data_offset = sw.Seek(0, SeekOrigin.Current);
var vertex_elements = mesh.VertexElements;
var VertexElmentsCount = vertex_elements.Count();
sw.Write((byte)VertexElmentsCount);
foreach (var vertex_element in vertex_elements)
{
sw.Write((byte)vertex_element.Usage);
sw.Write(vertex_element.UsageIndex);
sw.Write((ulong)vertex_element.Format);
}
sw.Write((ulong)mesh.IndexFormat);
if (mesh.IndexFormat == Platform.Render.EFormat.EF_R16UI)
{
sw.Write((ushort)mesh.VertexCount);
sw.Write((ushort)mesh.IndexCount);
}
else
{
sw.Write(mesh.VertexCount);
sw.Write(mesh.IndexCount);
}
foreach (var vertex_stream in mesh.VertexStreams)
{
sw.Write(vertex_stream);
}
sw.Write(mesh.IndexStream.ToArray());
var submesh_count = mesh.SubMeshs.Count();
sw.Write((byte)submesh_count);
foreach (var submesh in mesh.SubMeshs)
{
sw.Write(submesh.MaterialIndex);
sw.Write((byte)submesh.LodsDescription.Count());
var float3 = new byte[12];
var float2 = new byte[8];
sw.Write(float3); //pc
sw.Write(float3); //po
sw.Write(float2); //tc
sw.Write(float2); //to
foreach (var lod_desc in submesh.LodsDescription)
{
if (mesh.IndexFormat == Platform.Render.EFormat.EF_R16UI)
{
sw.Write((ushort)lod_desc.VertexNum);
sw.Write((ushort)lod_desc.VertexBase);
sw.Write((ushort)lod_desc.IndexNum);
sw.Write((ushort)lod_desc.IndexBase);
}
else
{
sw.Write(lod_desc.VertexNum);
sw.Write(lod_desc.VertexBase);
sw.Write(lod_desc.IndexNum);
sw.Write(lod_desc.IndexBase);
}
}
}
return(sw.Seek(0, SeekOrigin.Current) - data_offset);
}
public void Convert(string path)
{
var KlayGE_meshml = XDocument.Load(path);
var dir = Path.GetDirectoryName(path);
if (KlayGE_meshml.Root.Attribute("version").Value != "6")
{
throw new NotSupportedException();
}
//material pass output
/*
* (material
* (effect Shading)
* (albedo (float3))
* (albedo_tex)~macro
* (smoothness)
* (metaless)
* (normal)
* )
*/
var materials = new List <Tuple <string, MaterialAsset> >();
foreach (var material_node in KlayGE_meshml.XPathSelectElements("//material"))
{
var material = new MaterialAsset();
var material_name = materials.Count.ToString();
material.EffectName = "ForwardPointLightDiffuseShading";
var albedo_node = material_node.Element("albedo");
{
var albedo_float4 = albedo_node?.Attribute("color");
if (albedo_float4 != null)
{
var albedo = albedo_float4.Value;
var albedo_array = albedo.Substring(0, albedo.LastIndexOf(' ')).Split(' ').Select(component => component + 'f');
material["albedo"] = $"(float3 {string.Join(' ',albedo_array)})";
}
var albedo_texture = albedo_node?.Attribute("texture");
if (albedo_texture != null)
{
var albedo_tex = albedo_texture.Value;
material["albedo_tex"] = $"\"{albedo_tex}\"";
material_name = $"{material_name}_{Path.GetFileNameWithoutExtension(albedo_tex)}";
}
}
var metalness_node = material_node.Element("metalness");
{
var metalness = metalness_node?.Attribute("value");
if (metalness != null)
{
material["metalness"] = $"(float2 {metalness.Value}f 0)";
}
}
var glossiness_node = material_node.Element("glossiness");
{
var glossiness = glossiness_node?.Attribute("value");
var glossiness_texture = glossiness_node?.Attribute("texture");
if (glossiness != null)
{
var value = double.Parse(glossiness.Value);
material["glossiness"] = $"(float2 {value}f {(glossiness_texture != null ? 1 : 0)})";
}
if (glossiness_texture != null)
{
var glossiness_tex = glossiness_texture.Value;
material["glossiness_tex"] = $"\"{glossiness_tex}\"";
material_name = $"{material_name}_{Path.GetFileNameWithoutExtension(glossiness_tex)}";
}
}
//todo support normal map
var material_tuple = Tuple.Create(material_name, material);
materials.Add(material_tuple);
var material_file = material_name + ".mat.lsl";
X.SaveMaterialAsset(Path.Combine(dir, material_file), material);
}
var meshes = new List <Tuple <string, string> >();
foreach (var mesh_node in KlayGE_meshml.XPathSelectElements("//mesh"))
{
var mesh = new MeshAsset();
var vertices_node = mesh_node.XPathSelectElements("vertices_chunk/vertex");
var vertices = vertices_node.Select(vertex_node =>
{
var pos_array = vertex_node.Attribute("v").Value.Split(' ').Select(component => float.Parse(component)).ToArray();
var pos = new float3(pos_array[0], pos_array[1], pos_array[2]);
var tangent_quat_array = vertex_node.Element("tangent_quat").Attribute("v").Value.Split(' ').Select(component => float.Parse(component)).ToArray();
var tangnet_quat = new float4(tangent_quat_array[0], tangent_quat_array[1], tangent_quat_array[2], tangent_quat_array[3]);
var tangent = transform_quat(new float3(1, 0, 0), tangnet_quat);
var binormal = transform_quat(new float3(0, 1, 0), tangnet_quat) * (tangnet_quat.w < 0?-1.0f:1.0f);
var normal = transform_quat(new float3(0, 0, 1), tangnet_quat);
var tex_coord_array = vertex_node.Element("tex_coord").Attribute("v").Value.Split(' ').Select(component => float.Parse(component)).ToArray();
var tex_coord = new float2(tex_coord_array[0], tex_coord_array[1]);
return(Tuple.Create(pos, normal, tex_coord));
}).ToList();
using (var stream = new MemoryStream())
using (var bw = new BinaryWriter(stream))
{
foreach (var vertex in vertices)
{
var pos = vertex.Item1;
bw.Write(pos.x);
bw.Write(pos.y);
bw.Write(pos.z);
}
bw.Flush();
var pos_element = new leo.Platform.Render.Vertex.Element();
pos_element.Format = EFormat.EF_BGR32F;
pos_element.Usage = leo.Platform.Render.Vertex.Usage.Position;
pos_element.UsageIndex = 0;
mesh.AddVertexStream(pos_element, stream.ToArray());
}
using (var stream = new MemoryStream())
using (var bw = new BinaryWriter(stream))
{
foreach (var vertex in vertices)
{
var normal = vertex.Item2;
bw.Write(normal.x);
bw.Write(normal.y);
bw.Write(normal.z);
}
bw.Flush();
var normal_element = new leo.Platform.Render.Vertex.Element();
normal_element.Format = EFormat.EF_BGR32F;
normal_element.Usage = leo.Platform.Render.Vertex.Usage.Normal;
normal_element.UsageIndex = 0;
mesh.AddVertexStream(normal_element, stream.ToArray());
}
using (var stream = new MemoryStream())
using (var bw = new BinaryWriter(stream))
{
foreach (var vertex in vertices)
{
var tex_coord = vertex.Item3;
bw.Write(tex_coord.x);
bw.Write(tex_coord.y);
}
bw.Flush();
var texcoord_element = new leo.Platform.Render.Vertex.Element();
texcoord_element.Format = EFormat.EF_GR32F;
texcoord_element.Usage = leo.Platform.Render.Vertex.Usage.TextureCoord;
texcoord_element.UsageIndex = 0;
mesh.AddVertexStream(texcoord_element, stream.ToArray());
}
var triangles_node = mesh_node.XPathSelectElements("triangles_chunk/triangle");
var triangles = triangles_node.Select(triangle_node =>
triangle_node.Attribute("index").Value.Split(' ')
.Select(index => uint.Parse(index)))
.SelectMany(triangle => triangle)
.ToList();
var index_format = EFormat.EF_R16UI;
if (triangles.Count > short.MaxValue)
{
index_format = EFormat.EF_R32UI;
}
var use_16 = index_format == EFormat.EF_R16UI;
using (var stream = new MemoryStream())
using (var bw = new BinaryWriter(stream))
{
foreach (var index in triangles)
{
if (use_16)
{
bw.Write((ushort)index);
}
else
{
bw.Write(index);
}
}
bw.Flush();
mesh.SetIndexStream(index_format, stream.ToArray());
}
mesh.IndexCount = (uint)triangles.Count;
mesh.VertexCount = (uint)vertices.Count;
var submesh = new MeshAsset.SubMeshDescrption()
{
MaterialIndex = 0,
};
submesh.AddLodDesciption(new MeshAsset.SubMeshDescrption.LodDescription()
{
IndexBase = 0,
IndexNum = mesh.IndexCount,
VertexBase = 0,
VertexNum = mesh.VertexCount
});
mesh.AddSubMeshDescrption(submesh);
var mesh_name = mesh_node.Attribute("name").Value;
X.SaveMeshAsset(Path.Combine(dir, mesh_name + ".asset"), mesh);
var mtl_id = int.Parse(mesh_node.Attribute("mtl_id").Value);
var material_name = materials[mtl_id].Item1;
var mesh_tuple = Tuple.Create(mesh_name, material_name);
meshes.Add(mesh_tuple);
}
var filename = Path.Combine(dir, Path.GetFileNameWithoutExtension(path) + ".entities.lsl");
using (var stream = File.OpenWrite(filename))
using (var writer = new StreamWriter(stream))
{
writer.WriteLine("(entities");
foreach (var mesh_tuple in meshes)
{
writer.WriteLine($"\t(entity (mesh {mesh_tuple.Item1}) (material {mesh_tuple.Item2}))");
}
writer.WriteLine(")");
}
}
public static bool UpdateAsset(Object asset,
out string error, out string successMessage)
{
error = "";
successMessage = "";
if (asset is MeshAsset)
{
MeshAsset mesh = asset as MeshAsset;
var result = ImportMesh.import(mesh.SourceFilename, mesh.ImportedFilename);
if (string.IsNullOrEmpty(result))
{
successMessage = "Successfully updated mesh: " + mesh.Name;
mesh.LastUpdated = DateTime.Now;
AssetMetadata.createMeshMetadata(mesh);
return(true);
}
}
else if (asset is TextureAsset)
{
TextureAsset texture = asset as TextureAsset;
var result = ImportTexture.import(texture.Format, texture.ChannelMappings, texture.ImportedFilename);
if (string.IsNullOrEmpty(result))
{
successMessage = "Successfully updated texture: " + texture.Name;
texture.LastUpdated = DateTime.Now;
AssetMetadata.createTextureMetadata(texture);
return(true);
}
else
{
error = "ERROR: Updating texture: " + texture.Name + " failed!" + Environment.NewLine + result;
}
}
else if (asset is ShaderAsset)
{
ShaderAsset shader = asset as ShaderAsset;
var result = ImportShader.import(shader.SourceFilename, shader.ImportedFilename);
if (string.IsNullOrEmpty(result))
{
successMessage = "Successfully updated shader: " + shader.Name;
shader.LastUpdated = DateTime.Now;
AssetMetadata.createShaderMetadata(shader);
return(true);
}
else
{
error = "ERROR: Updating shader: " + shader.Name + " failed!" + Environment.NewLine + result;
}
}
else if (asset is MaterialAsset)
{
MaterialAsset material = asset as MaterialAsset;
var result = MaterialImporter.Import(material);
if (result)
{
successMessage = "Successfully updated material: " + material.Name;
material.LastUpdated = DateTime.Now;
AssetMetadata.createMaterialMetadata(material);
return(true);
}
else
{
error = "ERROR: Updating material: " + material.Name + " failed!" + Environment.NewLine;
}
}
else if (asset is StateGroupAsset)
{
var stateGroup = asset as StateGroupAsset;
var result = StateGroupImporter.Import(stateGroup);
if (result)
{
successMessage = "Successfully updated state group: " + stateGroup.Name;
stateGroup.LastUpdated = DateTime.Now;
AssetMetadata.createStateGroupMetadata(stateGroup);
return(true);
}
else
{
error = "ERROR: Updating state group: " + stateGroup.Name + " failed!" + Environment.NewLine + result;
}
}
return(false);
}
private void OnDestroy()
{
this.oSelfAsset = null;
}
public static void SaveMeshAsset(string path, MeshAsset mesh)
{
mesh.Save(path);
}
// 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.");
}
}
}
}
