/// <summary> /// Unconditionally export this mesh object to the file. /// We have decided; this mesh is definitely getting exported. /// </summary> public FbxMesh ExportMesh(GameObject unityGo, FbxScene fbxScene) { var meshInfo = GetMeshInfo(unityGo); if (!meshInfo.IsValid) { return(null); } // create the mesh structure. FbxMesh fbxMesh = FbxMesh.Create(fbxScene, "Scene"); // Create control points. int NumControlPoints = meshInfo.VertexCount; fbxMesh.InitControlPoints(NumControlPoints); // copy control point data from Unity to FBX for (int v = 0; v < NumControlPoints; v++) { fbxMesh.SetControlPointAt(new FbxVector4(meshInfo.Vertices [v].x, meshInfo.Vertices [v].y, meshInfo.Vertices [v].z), v); } for (int f = 0; f < meshInfo.Triangles.Length / 3; f++) { fbxMesh.BeginPolygon(); fbxMesh.AddPolygon(meshInfo.Triangles [3 * f]); fbxMesh.AddPolygon(meshInfo.Triangles [3 * f + 1]); fbxMesh.AddPolygon(meshInfo.Triangles [3 * f + 2]); fbxMesh.EndPolygon(); } return(fbxMesh); }
public static FbxMesh AddCompletePolygon(this FbxMesh mesh, params int[] vertexIndices) { mesh.BeginPolygon(); foreach (int vertexIndex in vertexIndices) { mesh.AddPolygon(vertexIndex); } mesh.EndPolygon(); return(mesh); }
/// <summary> /// Unconditionally export this mesh object to the file. /// We have decided; this mesh is definitely getting exported. /// </summary> public void ExportMesh(MeshInfo mesh, FbxNode fbxNode, FbxScene fbxScene) { if (!mesh.IsValid) { return; } NumMeshes++; NumTriangles += mesh.Triangles.Length / 3; NumVertices += mesh.VertexCount; // create the mesh structure. FbxMesh fbxMesh = FbxMesh.Create(fbxScene, "Mesh"); // Create control points. int NumControlPoints = mesh.VertexCount; fbxMesh.InitControlPoints(NumControlPoints); // copy control point data from Unity to FBX for (int v = 0; v < NumControlPoints; v++) { // convert from left to right-handed by negating x (Unity negates x again on import) fbxMesh.SetControlPointAt(new FbxVector4(-mesh.Vertices [v].x, mesh.Vertices [v].y, mesh.Vertices [v].z), v); } ExportNormalsEtc(mesh, fbxMesh); ExportVertexColors(mesh, fbxMesh); ExportUVs(mesh, fbxMesh); /* * Create polygons * Triangles have to be added in reverse order, * or else they will be inverted on import * (due to the conversion from left to right handed coords) */ for (int f = 0; f < mesh.Triangles.Length / 3; f++) { fbxMesh.BeginPolygon(); fbxMesh.AddPolygon(mesh.Triangles [3 * f + 2]); fbxMesh.AddPolygon(mesh.Triangles [3 * f + 1]); fbxMesh.AddPolygon(mesh.Triangles [3 * f]); fbxMesh.EndPolygon(); } // set the fbxNode containing the mesh fbxNode.SetNodeAttribute(fbxMesh); fbxNode.SetShadingMode(FbxNode.EShadingMode.eWireFrame); }
/// <summary> /// Unconditionally export this mesh object to the file. /// We have decided; this mesh is definitely getting exported. /// </summary> public FbxNode ExportMesh(MeshInfo meshInfo, FbxScene fbxScene, FbxNode fbxNode) { if (!meshInfo.IsValid) { Debug.LogError("Invalid mesh info"); return(null); } // create a node for the mesh FbxNode meshNode = FbxNode.Create(fbxScene, "geo"); // create the mesh structure. FbxMesh fbxMesh = FbxMesh.Create(fbxScene, "Mesh"); // Create control points. int NumControlPoints = meshInfo.VertexCount; fbxMesh.InitControlPoints(NumControlPoints); // copy control point data from Unity to FBX for (int v = 0; v < NumControlPoints; v++) { // convert from left to right-handed by negating x (Unity negates x again on import) fbxMesh.SetControlPointAt(new FbxVector4(-meshInfo.Vertices [v].x, meshInfo.Vertices [v].y, meshInfo.Vertices [v].z), v); } /* * Create polygons * Triangles have to be added in reverse order, * or else they will be inverted on import * (due to the conversion from left to right handed coords) */ for (int f = 0; f < meshInfo.Triangles.Length / 3; f++) { fbxMesh.BeginPolygon(); fbxMesh.AddPolygon(meshInfo.Triangles [3 * f + 2]); fbxMesh.AddPolygon(meshInfo.Triangles [3 * f + 1]); fbxMesh.AddPolygon(meshInfo.Triangles [3 * f]); fbxMesh.EndPolygon(); } // set the fbxNode containing the mesh meshNode.SetNodeAttribute(fbxMesh); meshNode.SetShadingMode(FbxNode.EShadingMode.eWireFrame); fbxNode.AddChild(meshNode); return(meshNode); }
/// <summary> /// Unconditionally export this mesh object to the file. /// We have decided; this mesh is definitely getting exported. /// </summary> public FbxMesh ExportMesh(MeshInfo meshInfo, FbxNode fbxNode, FbxScene fbxScene) { if (!meshInfo.IsValid) { return(null); } // create the mesh structure. FbxMesh fbxMesh = FbxMesh.Create(fbxScene, "Mesh"); // Create control points. int NumControlPoints = meshInfo.VertexCount; fbxMesh.InitControlPoints(NumControlPoints); // copy control point data from Unity to FBX for (int v = 0; v < NumControlPoints; v++) { // convert from left to right-handed by negating x (Unity negates x again on import) fbxMesh.SetControlPointAt(new FbxVector4(-meshInfo.Vertices [v].x, meshInfo.Vertices [v].y, meshInfo.Vertices [v].z), v); } ExportNormalsEtc(meshInfo, fbxMesh); ExportUVs(meshInfo, fbxMesh); var fbxMaterial = ExportMaterial(meshInfo.Material, fbxScene); fbxNode.AddMaterial(fbxMaterial); /* * Create polygons after FbxLayerElementMaterial have been created. * Triangles have to be added in reverse order, * or else they will be inverted on import * (due to the conversion from left to right handed coords) */ for (int f = 0; f < meshInfo.Triangles.Length / 3; f++) { fbxMesh.BeginPolygon(); fbxMesh.AddPolygon(meshInfo.Triangles [3 * f + 2]); fbxMesh.AddPolygon(meshInfo.Triangles [3 * f + 1]); fbxMesh.AddPolygon(meshInfo.Triangles [3 * f]); fbxMesh.EndPolygon(); } return(fbxMesh); }
protected override FbxScene CreateScene(FbxManager manager) { // Create a cube as a static mesh FbxScene scene = FbxScene.Create(manager, "myScene"); FbxNode meshNode = FbxNode.Create(scene, "MeshNode"); FbxMesh cubeMesh = FbxMesh.Create(scene, "cube"); meshNode.SetNodeAttribute(cubeMesh); scene.GetRootNode().AddChild(meshNode); cubeMesh.InitControlPoints(24); for (int i = 0; i < cubeMesh.GetControlPointsCount(); i++) { cubeMesh.SetControlPointAt(m_controlPoints [i], i); } // A cube: 6 polygons with 4 vertices each int[] vertices = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 }; for (int i = 0; i < 6; i++) { cubeMesh.BeginPolygon(pGroup: -1); for (int j = 0; j < 4; j++) { cubeMesh.AddPolygon(vertices[i * 4 + j]); } cubeMesh.EndPolygon(); } return(scene); }
/// <summary> /// Unconditionally export this mesh object to the file. /// We have decided; this mesh is definitely getting exported. /// </summary> public void ExportMesh(MeshInfo mesh, FbxNode fbxNode, FbxScene fbxScene) { if (!mesh.IsValid) { return; } NumMeshes++; NumTriangles += mesh.Triangles.Length / 3; NumVertices += mesh.VertexCount; // create the mesh structure. FbxMesh fbxMesh = FbxMesh.Create(fbxScene, "Mesh"); // Create control points. int NumControlPoints = mesh.VertexCount; fbxMesh.InitControlPoints(NumControlPoints); // copy control point data from Unity to FBX for (int v = 0; v < NumControlPoints; v++) { fbxMesh.SetControlPointAt(new FbxVector4(mesh.Vertices[v].x, mesh.Vertices[v].y, mesh.Vertices[v].z), v); } /* * Create polygons after FbxGeometryElementMaterial are created. * TODO: Assign material indices. */ int vId = 0; for (int f = 0; f < mesh.Triangles.Length / 3; f++) { fbxMesh.BeginPolygon(); fbxMesh.AddPolygon(mesh.Triangles [vId++]); fbxMesh.AddPolygon(mesh.Triangles [vId++]); fbxMesh.AddPolygon(mesh.Triangles [vId++]); fbxMesh.EndPolygon(); } // set the fbxNode containing the mesh fbxNode.SetNodeAttribute(fbxMesh); fbxNode.SetShadingMode(FbxNode.EShadingMode.eWireFrame); }
// For use only by FbxExportGlobals. internal static FbxMesh CreateFbxMesh(FbxExportGlobals G, GeometryPool pool, string poolName) { FbxMesh fbxMesh = FbxMesh.Create(G.m_manager, poolName); ExportMesh mesh = new ExportMesh(pool); int nVerts = mesh.m_pool.m_Vertices.Count; fbxMesh.InitControlPoints(nVerts); unsafe { fixed(Vector3 *f = mesh.m_pool.m_Vertices.GetBackingArray()) { Globals.SetControlPoints(fbxMesh, (IntPtr)f); } } List <int> triangles = mesh.m_pool.m_Tris; // Not available in Unity's wrappers // fbxMesh.ReservePolygonCount(triangles.Count / 3); // fbxMesh.ReservePolygonVertexCount(triangles.Count); for (int i = 0; i < triangles.Count; i += 3) { fbxMesh.BeginPolygon(-1 /* Material */, -1 /* Texture */, -1 /* Group */, false /* Legacy */); fbxMesh.AddPolygon(triangles[i]); fbxMesh.AddPolygon(triangles[i + 1]); fbxMesh.AddPolygon(triangles[i + 2]); fbxMesh.EndPolygon(); } FbxLayer layer0 = fbxMesh.GetLayer(0); if (layer0 == null) { fbxMesh.CreateLayer(); layer0 = fbxMesh.GetLayer(0); } var layerElementNormal = FbxLayerElementNormal.Create(fbxMesh, "normals"); layerElementNormal.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint); layerElementNormal.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect); CopyToFbx(layerElementNormal.GetDirectArray(), mesh.m_pool.m_Normals); layer0.SetNormals(layerElementNormal); var layerElementColor = FbxLayerElementVertexColor.Create(fbxMesh, "color"); layerElementColor.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint); layerElementColor.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect); CopyToFbx(layerElementColor.GetDirectArray(), mesh.m_linearColor); layer0.SetVertexColors(layerElementColor); var layerElementTangent = FbxLayerElementTangent.Create(fbxMesh, "tangents"); layerElementTangent.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint); layerElementTangent.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect); CopyToFbx(layerElementTangent.GetDirectArray(), mesh.m_pool.m_Tangents); layer0.SetTangents(layerElementTangent); // Compute and export binormals since Unity's FBX importer won't import the tangents without // them, even though they're not used. var layerElementBinormal = FbxLayerElementBinormal.Create(fbxMesh, "binormals"); layerElementBinormal.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint); layerElementBinormal.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect); var binormals = mesh.m_pool.m_Tangents .Select((tan, idx) => { var b3 = Vector3.Cross(tan, mesh.m_pool.m_Normals[idx]) * tan.w; return(new Vector4(b3.x, b3.y, b3.z, 1)); }) .ToList(); CopyToFbx(layerElementBinormal.GetDirectArray(), binormals); layer0.SetBinormals(layerElementBinormal); var layerElementMaterial = FbxLayerElementMaterial.Create(fbxMesh, "materials"); layerElementMaterial.SetMappingMode(FbxLayerElement.EMappingMode.eAllSame); layer0.SetMaterials(layerElementMaterial); // Export everything up to the last uvset containing data // even if some intermediate uvsets have no data. // Otherwise Unity will get the uvset numbering wrong on import List <List <Vector2> > uvSets = DemuxTexcoords(mesh.m_pool); for (int i = 0; i < uvSets.Count; i++) { FbxLayer layerN = fbxMesh.GetLayer(i); while (layerN == null) { fbxMesh.CreateLayer(); layerN = fbxMesh.GetLayer(i); } var layerElementUV = FbxLayerElementUV.Create(fbxMesh, String.Format("uv{0}", i)); layerElementUV.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint); layerElementUV.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect); List <Vector2> uvSet = uvSets[i]; if (uvSet == null) { // Do nothing // Replicates what the old fbx export code did; seems to work fine } else { Debug.Assert(uvSet.Count == nVerts); CopyToFbx(layerElementUV.GetDirectArray(), uvSet); } layerN.SetUVs(layerElementUV, FbxLayerElement.EType.eTextureDiffuse); } return(fbxMesh); }