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