public void GeometryBase_InitControlPoints_InitsControlPoints()
{
// given:
var gb = new FbxMesh("");
// require:
Assert.AreEqual(0, gb.GetControlPointsCount());
// when:
gb.InitControlPoints(4);
// then:
Assert.AreEqual(4, gb.GetControlPointsCount());
// when:
gb.InitControlPoints(20);
// then:
Assert.AreEqual(20, gb.GetControlPointsCount());
// when:
gb.InitControlPoints(3);
// then:
Assert.AreEqual(3, gb.GetControlPointsCount());
}
/// <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);
}
/// <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);
}
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);
}
return(scene);
}
public void GeometryBase_SetControlPointAt_SetsControlPoint()
{
// given:
var gb = new FbxMesh("");
gb.InitControlPoints(4);
// require:
Assert.AreEqual(4, gb.GetControlPointsCount());
Assert.AreEqual(new FbxVector4(0, 0, 0, 0), gb.GetControlPointAt(0));
Assert.AreEqual(new FbxVector4(0, 0, 0, 0), gb.GetControlPointAt(1));
Assert.AreEqual(new FbxVector4(0, 0, 0, 0), gb.GetControlPointAt(2));
Assert.AreEqual(new FbxVector4(0, 0, 0, 0), gb.GetControlPointAt(3));
// when:
gb.SetControlPointAt(new FbxVector4(1.2, 3.4, 5.6, 7.8), 2);
// then:
Assert.AreEqual(new FbxVector4(0, 0, 0, 0), gb.GetControlPointAt(0));
Assert.AreEqual(new FbxVector4(0, 0, 0, 0), gb.GetControlPointAt(1));
Assert.AreEqual(new FbxVector4(1.2, 3.4, 5.6, 7.8), gb.GetControlPointAt(2));
Assert.AreEqual(new FbxVector4(0, 0, 0, 0), gb.GetControlPointAt(3));
}
// 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);
}
