using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using GLTF.Schema; using UnityEngine; using UnityEngine.Rendering; using UnityGLTF.Extensions; #if UNITY_EDITOR // required for in-editor access to non-readable meshes using UnityEditor; #endif namespace UnityGLTF { public partial class GLTFSceneExporter { private struct MeshAccessors { public AccessorId aPosition, aNormal, aTangent, aTexcoord0, aTexcoord1, aTexcoord2, aColor0; public Dictionary subMeshPrimitives; } private struct BlendShapeAccessors { public List> targets; public List weights; public List targetNames; } private readonly Dictionary _meshToPrims = new Dictionary(); private readonly Dictionary _meshToBlendShapeAccessors = new Dictionary(); public void RegisterPrimitivesWithNode(Node node, List uniquePrimitives) { // associate unity meshes with gltf mesh id foreach (var primKey in uniquePrimitives) { _primOwner[primKey] = node.Mesh; } } private static List GetUniquePrimitivesFromGameObjects(IEnumerable primitives) { var primKeys = new List(); foreach (var prim in primitives) { Mesh meshObj = null; SkinnedMeshRenderer smr = null; var filter = prim.GetComponent(); if (filter) { meshObj = filter.sharedMesh; } else { smr = prim.GetComponent(); if (smr) { meshObj = smr.sharedMesh; } } if (!meshObj) { Debug.LogWarning($"MeshFilter.sharedMesh on GameObject:{prim.name} is missing, skipping", prim); exportPrimitiveMarker.End(); return null; } #if UNITY_EDITOR if (!MeshIsReadable(meshObj) && EditorUtility.IsPersistent(meshObj)) { #if UNITY_2019_3_OR_NEWER var assetPath = AssetDatabase.GetAssetPath(meshObj); if (assetPath?.Length > 30) assetPath = "..." + assetPath.Substring(assetPath.Length - 30); var otherOption = Application.isPlaying ? "No, skip mesh" : "Cancel export"; if(EditorUtility.DisplayDialog("Exporting mesh but mesh is not readable", $"The mesh {meshObj.name} is not readable. Do you want to change its import settings and make it readable now?\n\n" + assetPath, "Make it readable", otherOption, DialogOptOutDecisionType.ForThisSession, MakeMeshReadableDialogueDecisionKey)) #endif { var path = AssetDatabase.GetAssetPath(meshObj); var importer = AssetImporter.GetAtPath(path) as ModelImporter; if (importer) { importer.isReadable = true; importer.SaveAndReimport(); } } #if UNITY_2019_3_OR_NEWER else { if (Application.isPlaying) { Debug.LogWarning(null, $"The mesh {meshObj.name} is not readable. Skipping", meshObj); exportPrimitiveMarker.End(); } else { Debug.LogError(null, $"The mesh {meshObj.name} is not readable and you decided to cancel the export. Canceling", meshObj); exportPrimitiveMarker.End(); throw new OperationCanceledException($"Canceled export because a mesh ({meshObj}) is not readable."); } return null; } #endif } #endif if (Application.isPlaying && !MeshIsReadable(meshObj)) { Debug.LogWarning($"The mesh {meshObj.name} is not readable. Skipping", null); exportPrimitiveMarker.End(); return null; } var renderer = prim.GetComponent(); if (!renderer) smr = prim.GetComponent(); if(!renderer && !smr) { Debug.LogWarning("GameObject does have neither renderer nor SkinnedMeshRenderer! " + prim.name, prim); exportPrimitiveMarker.End(); return null; } var materialsObj = renderer ? renderer.sharedMaterials : smr.sharedMaterials; var primKey = new UniquePrimitive(); primKey.Mesh = meshObj; primKey.Materials = materialsObj; primKey.SkinnedMeshRenderer = smr; primKeys.Add(primKey); } return primKeys; } public NodeId ExportNode(GameObject gameObject) => ExportNode(gameObject.transform); /// /// Convenience wrapper around ExportMesh(string, List) /// public MeshId ExportMesh(Mesh mesh) { var uniquePrimitives = new List { new UniquePrimitive() { Mesh = mesh, SkinnedMeshRenderer = null, Materials = new [] { DefaultMaterial }, } }; return ExportMesh(mesh.name, uniquePrimitives); } public MeshId ExportMesh(string name, List uniquePrimitives) { exportMeshMarker.Begin(); // check if this set of primitives is already a mesh MeshId existingMeshId = null; foreach (var prim in uniquePrimitives) { MeshId tempMeshId; if (_primOwner.TryGetValue(prim, out tempMeshId) && (existingMeshId == null || tempMeshId == existingMeshId)) { existingMeshId = tempMeshId; } else { existingMeshId = null; break; } } // if so, return that mesh id if (existingMeshId != null) { exportMeshMarker.End(); return existingMeshId; } // if not, create new mesh and return its id var mesh = new GLTFMesh(); if (settings.ExportNames) { mesh.Name = name; } mesh.Primitives = new List(uniquePrimitives.Count); foreach (var primKey in uniquePrimitives) { MeshPrimitive[] meshPrimitives = ExportPrimitive(primKey, mesh); if (meshPrimitives != null) { mesh.Primitives.AddRange(meshPrimitives); } } var id = new MeshId { Id = _root.Meshes.Count, Root = _root }; exportMeshMarker.End(); if (mesh.Primitives.Count > 0) { _root.Meshes.Add(mesh); return id; } return null; } // a mesh *might* decode to multiple prims if there are submeshes private MeshPrimitive[] ExportPrimitive(UniquePrimitive primKey, GLTFMesh mesh) { exportPrimitiveMarker.Begin(); Mesh meshObj = primKey.Mesh; Material[] materialsObj = primKey.Materials; var prims = new MeshPrimitive[meshObj.subMeshCount]; List nonEmptyPrims = null; var vertices = meshObj.vertices; if (vertices.Length < 1) { Debug.LogWarning(null, "MeshFilter does not contain any vertices or they can't be accessed, won't export: " + meshObj.name, meshObj); exportPrimitiveMarker.End(); return null; } if (!_meshToPrims.ContainsKey(meshObj)) { AccessorId aPosition = null, aNormal = null, aTangent = null, aTexcoord0 = null, aTexcoord1 = null, aTexcoord2 = null, aColor0 = null; aPosition = ExportAccessor(SchemaExtensions.ConvertVector3CoordinateSpaceAndCopy(meshObj.vertices, SchemaExtensions.CoordinateSpaceConversionScale)); if (meshObj.normals.Length != 0) aNormal = ExportAccessor(SchemaExtensions.ConvertVector3CoordinateSpaceAndCopy(meshObj.normals, SchemaExtensions.CoordinateSpaceConversionScale)); if (meshObj.tangents.Length != 0) aTangent = ExportAccessor(SchemaExtensions.ConvertVector4CoordinateSpaceAndCopy(meshObj.tangents, SchemaExtensions.TangentSpaceConversionScale)); if (meshObj.uv.Length != 0) aTexcoord0 = ExportAccessor(SchemaExtensions.FlipTexCoordArrayVAndCopy(meshObj.uv)); if (meshObj.uv2.Length != 0) aTexcoord1 = ExportAccessor(SchemaExtensions.FlipTexCoordArrayVAndCopy(meshObj.uv2)); if (meshObj.uv3.Length != 0) aTexcoord2 = ExportAccessor(SchemaExtensions.FlipTexCoordArrayVAndCopy(meshObj.uv3)); if (settings.ExportVertexColors && meshObj.colors.Length != 0) aColor0 = ExportAccessor(QualitySettings.activeColorSpace == ColorSpace.Linear ? meshObj.colors : meshObj.colors.ToLinear(), true); aPosition.Value.BufferView.Value.Target = BufferViewTarget.ArrayBuffer; if (aNormal != null) aNormal.Value.BufferView.Value.Target = BufferViewTarget.ArrayBuffer; if (aTangent != null) aTangent.Value.BufferView.Value.Target = BufferViewTarget.ArrayBuffer; if (aTexcoord0 != null) aTexcoord0.Value.BufferView.Value.Target = BufferViewTarget.ArrayBuffer; if (aTexcoord1 != null) aTexcoord1.Value.BufferView.Value.Target = BufferViewTarget.ArrayBuffer; if (aTexcoord2 != null) aTexcoord2.Value.BufferView.Value.Target = BufferViewTarget.ArrayBuffer; if (aColor0 != null) aColor0.Value.BufferView.Value.Target = BufferViewTarget.ArrayBuffer; _meshToPrims.Add(meshObj, new MeshAccessors() { aPosition = aPosition, aNormal = aNormal, aTangent = aTangent, aTexcoord0 = aTexcoord0, aTexcoord1 = aTexcoord1, aTexcoord2 = aTexcoord2, aColor0 = aColor0, subMeshPrimitives = new Dictionary() }); } var accessors = _meshToPrims[meshObj]; // walk submeshes and export the ones with non-null meshes for (int submesh = 0; submesh < meshObj.subMeshCount; submesh++) { var mat = materialsObj[submesh % materialsObj.Length]; if (!mat) continue; if (!accessors.subMeshPrimitives.ContainsKey(submesh)) { var primitive = new MeshPrimitive(); var topology = meshObj.GetTopology(submesh); var indices = meshObj.GetIndices(submesh); if (topology == MeshTopology.Triangles) SchemaExtensions.FlipTriangleFaces(indices); primitive.Mode = GetDrawMode(topology); primitive.Indices = ExportAccessor(indices, true); primitive.Indices.Value.BufferView.Value.Target = BufferViewTarget.ElementArrayBuffer; primitive.Attributes = new Dictionary(); primitive.Attributes.Add(SemanticProperties.POSITION, accessors.aPosition); if (accessors.aNormal != null) primitive.Attributes.Add(SemanticProperties.NORMAL, accessors.aNormal); if (accessors.aTangent != null) primitive.Attributes.Add(SemanticProperties.TANGENT, accessors.aTangent); if (accessors.aTexcoord0 != null) primitive.Attributes.Add(SemanticProperties.TEXCOORD_0, accessors.aTexcoord0); if (accessors.aTexcoord1 != null) primitive.Attributes.Add(SemanticProperties.TEXCOORD_1, accessors.aTexcoord1); if (accessors.aTexcoord2 != null) primitive.Attributes.Add(SemanticProperties.TEXCOORD_2, accessors.aTexcoord2); if (accessors.aColor0 != null) primitive.Attributes.Add(SemanticProperties.COLOR_0, accessors.aColor0); primitive.Material = null; ExportBlendShapes(primKey.SkinnedMeshRenderer, meshObj, submesh, primitive, mesh); accessors.subMeshPrimitives.Add(submesh, primitive); } var submeshPrimitive = accessors.subMeshPrimitives[submesh]; prims[submesh] = new MeshPrimitive(submeshPrimitive, _root) { Material = ExportMaterial(mat), }; accessors.subMeshPrimitives[submesh] = prims[submesh]; } nonEmptyPrims = new List(prims.Length); for (var i = 0; i < prims.Length; i++) { var prim = prims[i]; // remove any prims that have empty triangles if (EmptyPrimitive(prim)) continue; // invoke pre export event _exportOptions.AfterPrimitiveExport?.Invoke(this, meshObj, prim, i); nonEmptyPrims.Add(prim); } prims = nonEmptyPrims.ToArray(); exportPrimitiveMarker.End(); return prims; } // Blend Shapes / Morph Targets // Adopted from Gary Hsu (bghgary) // https://github.com/bghgary/glTF-Tools-for-Unity/blob/master/UnityProject/Assets/Gltf/Editor/Exporter.cs private void ExportBlendShapes(SkinnedMeshRenderer smr, Mesh meshObj, int submeshIndex, MeshPrimitive primitive, GLTFMesh mesh) { if (settings.BlendShapeExportProperties == GLTFSettings.BlendShapeExportPropertyFlags.None) return; if (_meshToBlendShapeAccessors.TryGetValue(meshObj, out var data)) { mesh.Weights = data.weights; primitive.Targets = data.targets; primitive.TargetNames = data.targetNames; return; } if (smr != null && meshObj.blendShapeCount > 0) { List> targets = new List>(meshObj.blendShapeCount); List weights = new List(meshObj.blendShapeCount); List targetNames = new List(meshObj.blendShapeCount); #if UNITY_2019_3_OR_NEWER var meshHasNormals = meshObj.HasVertexAttribute(VertexAttribute.Normal); var meshHasTangents = meshObj.HasVertexAttribute(VertexAttribute.Tangent); #else var meshHasNormals = meshObj.normals.Length > 0; var meshHasTangents = meshObj.tangents.Length > 0; #endif for (int blendShapeIndex = 0; blendShapeIndex < meshObj.blendShapeCount; blendShapeIndex++) { exportBlendShapeMarker.Begin(); targetNames.Add(meshObj.GetBlendShapeName(blendShapeIndex)); // As described above, a blend shape can have multiple frames. Given that glTF only supports a single frame // per blend shape, we'll always use the final frame (the one that would be for when 100% weight is applied). int frameIndex = meshObj.GetBlendShapeFrameCount(blendShapeIndex) - 1; var deltaVertices = new Vector3[meshObj.vertexCount]; var deltaNormals = new Vector3[meshObj.vertexCount]; var deltaTangents = new Vector3[meshObj.vertexCount]; meshObj.GetBlendShapeFrameVertices(blendShapeIndex, frameIndex, deltaVertices, deltaNormals, deltaTangents); var exportTargets = new Dictionary(); if (!settings.BlendShapeExportSparseAccessors) { var positionAccessor = ExportAccessor(SchemaExtensions.ConvertVector3CoordinateSpaceAndCopy(deltaVertices, SchemaExtensions.CoordinateSpaceConversionScale)); positionAccessor.Value.BufferView.Value.Target = BufferViewTarget.ArrayBuffer; exportTargets.Add(SemanticProperties.POSITION, positionAccessor); } else { // Debug.Log("Delta Vertices:\n"+string.Join("\n ", deltaVertices)); // Debug.Log("Vertices:\n"+string.Join("\n ", meshObj.vertices)); // Experimental: sparse accessor. // - get the accessor we want to base this upon // - this is how position is originally exported: // ExportAccessor(SchemaExtensions.ConvertVector3CoordinateSpaceAndCopy(meshObj.vertices, SchemaExtensions.CoordinateSpaceConversionScale)); var baseAccessor = _meshToPrims[meshObj].aPosition; var exportedAccessor = ExportSparseAccessor(null, null, SchemaExtensions.ConvertVector3CoordinateSpaceAndCopy(deltaVertices, SchemaExtensions.CoordinateSpaceConversionScale)); if (exportedAccessor != null) { exportTargets.Add(SemanticProperties.POSITION, exportedAccessor); } } if (meshHasNormals && settings.BlendShapeExportProperties.HasFlag(GLTFSettings.BlendShapeExportPropertyFlags.Normal)) { if (!settings.BlendShapeExportSparseAccessors) { var accessor = ExportAccessor(SchemaExtensions.ConvertVector3CoordinateSpaceAndCopy(deltaNormals, SchemaExtensions.CoordinateSpaceConversionScale)); accessor.Value.BufferView.Value.Target = BufferViewTarget.ArrayBuffer; exportTargets.Add(SemanticProperties.NORMAL, accessor); } else { var baseAccessor = _meshToPrims[meshObj].aNormal; exportTargets.Add(SemanticProperties.NORMAL, ExportSparseAccessor(null, null, SchemaExtensions.ConvertVector3CoordinateSpaceAndCopy(deltaVertices, SchemaExtensions.CoordinateSpaceConversionScale))); } } if (meshHasTangents && settings.BlendShapeExportProperties.HasFlag(GLTFSettings.BlendShapeExportPropertyFlags.Tangent)) { if (!settings.BlendShapeExportSparseAccessors) { var accessor = ExportAccessor(SchemaExtensions.ConvertVector3CoordinateSpaceAndCopy(deltaTangents, SchemaExtensions.CoordinateSpaceConversionScale)); accessor.Value.BufferView.Value.Target = BufferViewTarget.ArrayBuffer; exportTargets.Add(SemanticProperties.TANGENT, accessor); } else { // var baseAccessor = _meshToPrims[meshObj].aTangent; // exportTargets.Add(SemanticProperties.TANGENT, ExportSparseAccessor(baseAccessor, SchemaExtensions.ConvertVector4CoordinateSpaceAndCopy(meshObj.tangents, SchemaExtensions.TangentSpaceConversionScale), SchemaExtensions.ConvertVector4CoordinateSpaceAndCopy(deltaVertices, SchemaExtensions.TangentSpaceConversionScale))); exportTargets.Add(SemanticProperties.TANGENT, ExportAccessor(SchemaExtensions.ConvertVector3CoordinateSpaceAndCopy(deltaTangents, SchemaExtensions.CoordinateSpaceConversionScale))); // Debug.LogWarning("Blend Shape Tangents for " + meshObj + " won't be exported with sparse accessors – sparse accessor for tangents isn't supported right now."); } } targets.Add(exportTargets); // We need to get the weight from the SkinnedMeshRenderer because this represents the currently // defined weight by the user to apply to this blend shape. If we instead got the value from // the unityMesh, it would be a _per frame_ weight, and for a single-frame blend shape, that would // always be 100. A blend shape might have more than one frame if a user wanted to more tightly // control how a blend shape will be animated during weight changes (e.g. maybe they want changes // between 0-50% to be really minor, but between 50-100 to be extreme, hence they'd have two frames // where the first frame would have a weight of 50 (meaning any weight between 0-50 should be relative // to the values in this frame) and then any weight between 50-100 would be relevant to the weights in // the second frame. See Post 20 for more info: // https://forum.unity3d.com/threads/is-there-some-method-to-add-blendshape-in-editor.298002/#post-2015679 if(exportTargets.Any()) weights.Add(smr.GetBlendShapeWeight(blendShapeIndex) / 100); exportBlendShapeMarker.End(); } if(weights.Any() && targets.Any()) { mesh.Weights = weights; primitive.Targets = targets; primitive.TargetNames = targetNames; } else { mesh.Weights = null; primitive.Targets = null; primitive.TargetNames = null; } // cache the exported data; we can re-use it between all submeshes of a mesh. _meshToBlendShapeAccessors.Add(meshObj, new BlendShapeAccessors() { targets = targets, weights = weights, targetNames = targetNames }); } } private static bool EmptyPrimitive(MeshPrimitive prim) { if (prim == null || prim.Attributes == null) { return true; } return false; } private static DrawMode GetDrawMode(MeshTopology topology) { switch (topology) { case MeshTopology.Points: return DrawMode.Points; case MeshTopology.Lines: return DrawMode.Lines; case MeshTopology.LineStrip: return DrawMode.LineStrip; case MeshTopology.Triangles: return DrawMode.Triangles; } throw new Exception("glTF does not support Unity mesh topology: " + topology); } #if UNITY_EDITOR private const string MakeMeshReadableDialogueDecisionKey = nameof(MakeMeshReadableDialogueDecisionKey); private static PropertyInfo canAccessProperty = typeof(Mesh).GetProperty("canAccess", BindingFlags.Instance | BindingFlags.Default | BindingFlags.NonPublic); #endif private static bool MeshIsReadable(Mesh mesh) { #if UNITY_EDITOR return mesh.isReadable || (bool) (canAccessProperty?.GetMethod?.Invoke(mesh, null) ?? true); #else return mesh.isReadable; #endif } } }