public bool EmulateNormalsByPolygonVertex(FbxMesh pMesh)
{
bool ret = fbx_wrapperPINVOKE.FbxGeometryConverter_EmulateNormalsByPolygonVertex(swigCPtr, FbxMesh.getCPtr(pMesh));
return ret;
}
public bool ComputePolygonSmoothingFromEdgeSmoothing(FbxMesh pMesh)
{
bool ret = NativeMethods.FbxGeometryConverter_ComputePolygonSmoothingFromEdgeSmoothing__SWIG_1(swigCPtr, FbxMesh.getCPtr(pMesh));
if (NativeMethods.SWIGPendingException.Pending)
{
throw NativeMethods.SWIGPendingException.Retrieve();
}
return(ret);
}
protected override void CheckScene(FbxScene scene)
{
base.CheckScene(scene);
FbxScene origScene = CreateScene(FbxManager);
Assert.IsNotNull(origScene);
// Retrieve the mesh from each scene
FbxMesh origMesh = origScene.GetRootNode().GetChild(0).GetMesh();
FbxMesh importMesh = scene.GetRootNode().GetChild(0).GetMesh();
// get the layers
FbxLayer origLayer = origMesh.GetLayer(0 /* default layer */);
FbxLayer importLayer = importMesh.GetLayer(0 /* default layer */);
// Check UVs
var origUVElement = origLayer.GetUVs();
var importUVElement = importLayer.GetUVs();
Assert.AreEqual(origUVElement.GetMappingMode(), importUVElement.GetMappingMode());
Assert.AreEqual(origUVElement.GetReferenceMode(), importUVElement.GetReferenceMode());
var origUVElementArray = origUVElement.GetDirectArray();
var importUVElementArray = importUVElement.GetDirectArray();
Assert.AreEqual(origUVElementArray.GetCount(), importUVElementArray.GetCount());
for (int i = 0; i < origUVElementArray.GetCount(); i++)
{
Assert.AreEqual(origUVElementArray.GetAt(i), importUVElementArray.GetAt(i));
}
var origUVElementIndex = origUVElement.GetIndexArray();
var importUVElementIndex = origUVElement.GetIndexArray();
Assert.AreEqual(origUVElementIndex.GetCount(), importUVElementIndex.GetCount());
for (int i = 0; i < origUVElementIndex.GetCount(); i++)
{
Assert.AreEqual(origUVElementIndex.GetAt(i), importUVElementIndex.GetAt(i));
}
// Check material and texture
var origNode = origScene.GetRootNode().GetChild(0);
int origMatIndex = origNode.GetMaterialIndex(m_materialName);
Assert.GreaterOrEqual(origMatIndex, 0);
var origMaterial = origNode.GetMaterial(origMatIndex);
Assert.IsNotNull(origMaterial);
var importNode = scene.GetRootNode().GetChild(0);
int importMatIndex = importNode.GetMaterialIndex(m_materialName);
Assert.GreaterOrEqual(importMatIndex, 0);
var importMaterial = importNode.GetMaterial(importMatIndex);
Assert.IsNotNull(importMaterial);
// TODO: Add ability to Downcast the material to an FbxSurfacePhong.
Property[] materialProperties =
{
new Property(FbxSurfaceMaterial.sDiffuse, PropertyType.Color),
new Property(FbxSurfaceMaterial.sEmissive, PropertyType.Color),
new Property(FbxSurfaceMaterial.sAmbient, PropertyType.Double3),
new Property(FbxSurfaceMaterial.sSpecular, PropertyType.Double3),
new Property(FbxSurfaceMaterial.sBumpFactor, PropertyType.Double)
};
FbxProperty origMaterialDiffuseProperty = null;
FbxProperty importMaterialDiffuseProperty = null;
foreach (var prop in materialProperties)
{
FbxProperty origProp = origMaterial.FindProperty(prop.name);
Assert.IsNotNull(origProp);
Assert.IsTrue(origProp.IsValid());
FbxProperty importProp = importMaterial.FindProperty(prop.name);
Assert.IsNotNull(importProp);
Assert.IsTrue(importProp.IsValid());
switch (prop.type)
{
case PropertyType.Color:
Assert.AreEqual(origProp.GetFbxColor(), importProp.GetFbxColor());
break;
case PropertyType.Double3:
Assert.AreEqual(origProp.GetFbxDouble3(), importProp.GetFbxDouble3());
break;
case PropertyType.Double:
Assert.AreEqual(origProp.GetDouble(), importProp.GetDouble());
break;
default:
break;
}
if (prop.name.Equals(FbxSurfaceMaterial.sDiffuse))
{
origMaterialDiffuseProperty = origProp;
importMaterialDiffuseProperty = importProp;
}
}
Assert.IsNotNull(origMaterialDiffuseProperty);
Assert.IsNotNull(importMaterialDiffuseProperty);
var origTexture = origMaterialDiffuseProperty.FindSrcObject(FbxSurfaceMaterial.sDiffuse + "_Texture");
Assert.IsNotNull(origTexture);
var importTexture = importMaterialDiffuseProperty.FindSrcObject(FbxSurfaceMaterial.sDiffuse + "_Texture");
Assert.IsNotNull(importTexture);
// TODO: Trying to Downcast the texture to an FbxFileTexture returns a null value,
// need to figure out how to fix this so we can access the texture properties.
/*Assert.AreEqual (origTexture.GetFileName (), importTexture.GetFileName ());
* Assert.AreEqual (origTexture.GetTextureUse (), importTexture.GetTextureUse ());
* Assert.AreEqual (origTexture.GetMappingType (), importTexture.GetMappingType ());*/
}
/// <summary>
/// Process mesh data and setup MeshFilter component
/// </summary>
private void ProcessMesh(FbxNode fbxNode, GameObject unityGo)
{
FbxMesh fbxMesh = fbxNode.GetMesh();
if (fbxMesh == null)
{
return;
}
var unityMesh = new Mesh();
// create mesh
var unityVertices = new List <Vector3> ();
var unityTriangleIndices = new List <int> ();
// transfer vertices
for (int i = 0; i < fbxMesh.GetControlPointsCount(); ++i)
{
FbxVector4 fbxVector4 = fbxMesh.GetControlPointAt(i);
Debug.Assert(fbxVector4.X <= float.MaxValue && fbxVector4.X >= float.MinValue);
Debug.Assert(fbxVector4.Y <= float.MaxValue && fbxVector4.Y >= float.MinValue);
Debug.Assert(fbxVector4.Z <= float.MaxValue && fbxVector4.Z >= float.MinValue);
unityVertices.Add(new Vector3((float)fbxVector4.X, (float)fbxVector4.Y, (float)fbxVector4.Z));
}
// transfer triangles
for (int polyIndex = 0; polyIndex < fbxMesh.GetPolygonCount(); ++polyIndex)
{
int polySize = fbxMesh.GetPolygonSize(polyIndex);
// only support triangles
Debug.Assert(polySize == 3);
for (int polyVertexIndex = 0; polyVertexIndex < polySize; ++polyVertexIndex)
{
int vertexIndex = fbxMesh.GetPolygonVertex(polyIndex, polyVertexIndex);
unityTriangleIndices.Add(vertexIndex);
}
}
unityMesh.vertices = unityVertices.ToArray();
// TODO:
// - support Mesh.SetTriangles - multiple materials per mesh
// - support Mesh.SetIndices - other topologies e.g. quads
unityMesh.triangles = unityTriangleIndices.ToArray();
unityMesh.RecalculateNormals();
var unityMeshFilter = unityGo.AddComponent <MeshFilter> ();
unityMeshFilter.sharedMesh = unityMesh;
var unityRenderer = unityGo.AddComponent <MeshRenderer> ();
{
// Assign the default material (hack!)
var unityPrimitive = GameObject.CreatePrimitive(PrimitiveType.Quad);
var unityMat = unityPrimitive.GetComponent <MeshRenderer> ().sharedMaterial;
unityRenderer.sharedMaterial = unityMat;
UnityEngine.Object.DestroyImmediate(unityPrimitive);
}
}
/// <summary>
/// Process UV data and configure the Mesh's UV attributes
/// </summary>
private void ProcessUVs(FbxMesh fbxMesh, Mesh unityMesh, int maxUVs = 4)
{
// Import UV sets (maximum defined by maxUVs)
int uvsetIndex = 0;
// First just try importing diffuse UVs from separate layers
// (Maya exports that way)
FbxLayerElementUV fbxFirstUVSet = null;
FbxLayer fbxFirstUVLayer = null;
// NOTE: assuming triangles
int polygonIndexCount = fbxMesh.GetPolygonVertexCount();
int vertexCount = fbxMesh.GetControlPointsCount();
int [] polygonVertexIndices = new int [polygonIndexCount];
int j = 0;
for (int polyIndex = 0; polyIndex < fbxMesh.GetPolygonCount(); ++polyIndex)
{
for (int positionInPolygon = 0; positionInPolygon < fbxMesh.GetPolygonSize(polyIndex); ++positionInPolygon)
{
polygonVertexIndices [j++] = fbxMesh.GetPolygonVertex(polyIndex, positionInPolygon);
}
}
for (int i = 0; i < fbxMesh.GetLayerCount(); i++)
{
FbxLayer fbxLayer = fbxMesh.GetLayer(i);
if (fbxLayer == null)
{
continue;
}
FbxLayerElementUV fbxUVSet = fbxLayer.GetUVs();
if (fbxUVSet == null)
{
continue;
}
if (fbxFirstUVSet != null)
{
fbxFirstUVSet = fbxUVSet;
fbxFirstUVLayer = fbxLayer;
}
switch (uvsetIndex)
{
case 0:
unityMesh.uv = ProcessUVSet(fbxUVSet, polygonVertexIndices, vertexCount);
break;
case 1:
unityMesh.uv2 = ProcessUVSet(fbxUVSet, polygonVertexIndices, vertexCount);
break;
case 2:
unityMesh.uv3 = ProcessUVSet(fbxUVSet, polygonVertexIndices, vertexCount);
break;
case 3:
unityMesh.uv4 = ProcessUVSet(fbxUVSet, polygonVertexIndices, vertexCount);
break;
}
uvsetIndex++;
if (uvsetIndex == maxUVs)
{
break;
}
}
// If we have received one UV set, check whether the same layer contains an emissive UV set
// that is different from diffuse UV set.
// 3dsmax FBX exporters doesn't export UV sets as different layers, instead for lightmapping usually
// a material is set up to have lightmap (2nd UV set) as self-illumination slot, and main texture
// (1st UV set) as diffuse slot.
if (uvsetIndex == 1 && fbxFirstUVSet != null)
{
FbxLayerElementUV fbxSecondaryUVSet = null;
// TODO: check if we've already passed eTextureEmissive layer
for (int i = (int)FbxLayerElement.EType.eTextureEmissive; i < (int)FbxLayerElement.EType.eTypeCount; i++)
{
fbxSecondaryUVSet = fbxFirstUVLayer.GetUVs((FbxLayerElement.EType)i);
if (fbxSecondaryUVSet != null)
{
break;
}
if (fbxSecondaryUVSet != null)
{
unityMesh.uv2 = ProcessUVSet(fbxSecondaryUVSet,
polygonVertexIndices,
vertexCount);
uvsetIndex++;
}
}
}
}
protected override void CheckScene(FbxScene scene)
{
base.CheckScene(scene);
FbxScene origScene = CreateScene(FbxManager);
Assert.IsNotNull(origScene);
// Retrieve the mesh from each scene
FbxMesh origMesh = origScene.GetRootNode().GetChild(0).GetMesh();
FbxMesh importMesh = scene.GetRootNode().GetChild(0).GetMesh();
// get the layers
FbxLayer origLayer = origMesh.GetLayer(0 /* default layer */);
FbxLayer importLayer = importMesh.GetLayer(0 /* default layer */);
// Check normals
CheckFbxElementVector4(origLayer.GetNormals(), importLayer.GetNormals());
// Check binormals
CheckFbxElementVector4(origLayer.GetBinormals(), importLayer.GetBinormals());
// Check tangents
CheckFbxElementVector4(origLayer.GetTangents(), importLayer.GetTangents());
// Check vertex colors
var origVertexColorElement = origLayer.GetVertexColors();
var importVertexColorElement = importLayer.GetVertexColors();
Assert.AreEqual(origVertexColorElement.GetMappingMode(), importVertexColorElement.GetMappingMode());
Assert.AreEqual(origVertexColorElement.GetReferenceMode(), importVertexColorElement.GetReferenceMode());
var origVertexColorElementArray = origVertexColorElement.GetDirectArray();
var importVertexColorElementArray = importVertexColorElement.GetDirectArray();
Assert.AreEqual(origVertexColorElementArray.GetCount(), importVertexColorElementArray.GetCount());
for (int i = 0; i < origVertexColorElementArray.GetCount(); i++)
{
Assert.AreEqual(origVertexColorElementArray.GetAt(i), importVertexColorElementArray.GetAt(i));
}
// Check UVs
var origUVElement = origLayer.GetUVs();
var importUVElement = importLayer.GetUVs();
Assert.AreEqual(origUVElement.GetMappingMode(), importUVElement.GetMappingMode());
Assert.AreEqual(origUVElement.GetReferenceMode(), importUVElement.GetReferenceMode());
var origUVElementArray = origUVElement.GetDirectArray();
var importUVElementArray = importUVElement.GetDirectArray();
Assert.AreEqual(origUVElementArray.GetCount(), importUVElementArray.GetCount());
for (int i = 0; i < origUVElementArray.GetCount(); i++)
{
Assert.AreEqual(origUVElementArray.GetAt(i), importUVElementArray.GetAt(i));
}
var origUVElementIndex = origUVElement.GetIndexArray();
var importUVElementIndex = origUVElement.GetIndexArray();
Assert.AreEqual(origUVElementIndex.GetCount(), importUVElementIndex.GetCount());
for (int i = 0; i < origUVElementIndex.GetCount(); i++)
{
Assert.AreEqual(origUVElementIndex.GetAt(i), importUVElementIndex.GetAt(i));
}
}
public SkinExporter(FbxMesh owner, SkinExportData soulsType) : base(owner, soulsType)
{
}
// 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);
}
public bool ComputePolygonSmoothingFromEdgeSmoothing(FbxMesh pMesh)
{
bool ret = fbx_wrapperPINVOKE.FbxGeometryConverter_ComputePolygonSmoothingFromEdgeSmoothing__SWIG_1(swigCPtr, FbxMesh.getCPtr(pMesh));
return ret;
}
public void TestBasics()
{
Assert.That(!string.IsNullOrEmpty(ModelExporter.GetVersionFromReadme()));
// Test GetOrCreateLayer
using (var fbxManager = FbxManager.Create()) {
var fbxMesh = FbxMesh.Create(fbxManager, "name");
var layer0 = ModelExporter.GetOrCreateLayer(fbxMesh);
Assert.That(layer0, Is.Not.Null);
Assert.That(ModelExporter.GetOrCreateLayer(fbxMesh), Is.EqualTo(layer0));
var layer5 = ModelExporter.GetOrCreateLayer(fbxMesh, layer: 5);
Assert.That(layer5, Is.Not.Null);
Assert.That(layer5, Is.Not.EqualTo(layer0));
}
// Test axis conversion: a x b in left-handed is the same as b x a
// in right-handed (that's why we need to flip the winding order).
var a = new Vector3(1, 0, 0);
var b = new Vector3(0, 0, 1);
var crossLeft = Vector3.Cross(a, b);
var afbx = ModelExporter.ConvertToRightHanded(a);
var bfbx = ModelExporter.ConvertToRightHanded(b);
Assert.AreEqual(ModelExporter.ConvertToRightHanded(crossLeft), bfbx.CrossProduct(afbx));
// Test scale conversion. Nothing complicated here...
var afbxPosition = ModelExporter.ConvertToRightHanded(a, ModelExporter.UnitScaleFactor);
Assert.AreEqual(100, afbxPosition.Length());
// Test rotation conversion.
var q = Quaternion.Euler(new Vector3(0, 90, 0));
var fbxAngles = ModelExporter.ConvertQuaternionToXYZEuler(q);
Assert.AreEqual(fbxAngles.X, 0);
Assert.That(fbxAngles.Y, Is.InRange(-90.001, -89.999));
Assert.AreEqual(fbxAngles.Z, 0);
Assert.That(ModelExporter.DefaultMaterial);
// Test non-static functions.
using (var fbxManager = FbxManager.Create()) {
var fbxScene = FbxScene.Create(fbxManager, "scene");
var fbxNode = FbxNode.Create(fbxScene, "node");
var exporter = new ModelExporter();
// Test ExportMaterial: it exports and it re-exports
bool result = exporter.ExportMaterial(ModelExporter.DefaultMaterial, fbxScene, fbxNode);
Assert.IsTrue(result);
var fbxMaterial = fbxNode.GetMaterial(0);
Assert.That(fbxMaterial, Is.Not.Null);
result = exporter.ExportMaterial(ModelExporter.DefaultMaterial, fbxScene, fbxNode);
var fbxMaterial2 = fbxNode.GetMaterial(1);
Assert.AreEqual(fbxMaterial, fbxMaterial2);
// Test ExportTexture: it finds the same texture for the default-material (it doesn't create a new one)
var fbxMaterialNew = FbxSurfaceLambert.Create(fbxScene, "lambert");
exporter.ExportTexture(ModelExporter.DefaultMaterial, "_MainTex",
fbxMaterialNew, FbxSurfaceLambert.sBump);
Assert.AreEqual(
fbxMaterial.FindProperty(FbxSurfaceLambert.sDiffuse).GetSrcObject(),
fbxMaterialNew.FindProperty(FbxSurfaceLambert.sBump).GetSrcObject()
);
// Test ExportMesh: make sure we exported a mesh with welded vertices.
var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
var cubeNode = FbxNode.Create(fbxScene, "cube");
exporter.ExportMesh(cube.GetComponent <MeshFilter>().sharedMesh, cubeNode);
Assert.That(cubeNode.GetMesh(), Is.Not.Null);
Assert.That(cubeNode.GetMesh().GetControlPointsCount(), Is.EqualTo(8));
}
// Test exporting a skinned-mesh. Make sure it doesn't leak (it did at one point)
{
var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
var character = new GameObject();
var smr = character.AddComponent <SkinnedMeshRenderer>();
smr.sharedMesh = cube.GetComponent <MeshFilter>().sharedMesh;
var meshCount = Object.FindObjectsOfType <Mesh>().Length;
ModelExporter.ExportObject(GetRandomFbxFilePath(), character);
Assert.AreEqual(meshCount, Object.FindObjectsOfType <Mesh>().Length);
}
}
public bool ComputeEdgeSmoothingFromPolygonSmoothing(FbxMesh pMesh, int pIndex)
{
bool ret = fbx_wrapperPINVOKE.FbxGeometryConverter_ComputeEdgeSmoothingFromPolygonSmoothing__SWIG_0(swigCPtr, FbxMesh.getCPtr(pMesh), pIndex);
return ret;
}
public bool ComputeEdgeSmoothingFromNormals(FbxMesh pMesh)
{
bool ret = fbx_wrapperPINVOKE.FbxGeometryConverter_ComputeEdgeSmoothingFromNormals(swigCPtr, FbxMesh.getCPtr(pMesh));
return ret;
}
public bool SplitMeshPerMaterial(FbxMesh pMesh, bool pReplace)
{
bool ret = fbx_wrapperPINVOKE.FbxGeometryConverter_SplitMeshPerMaterial(swigCPtr, FbxMesh.getCPtr(pMesh), pReplace);
return ret;
}
public static bool ExportToFBX(Component_Mesh sourceMesh, string realFileName, out string error)
{
//!!!!как для Vegetation. оверрайдить в Component_Mesh?
//get mesh data
var operations = new List <Component_RenderingPipeline.RenderSceneData.MeshDataRenderOperation>();
foreach (var geometry in sourceMesh.GetComponents <Component_MeshGeometry>())
{
if (geometry.Enabled)
{
geometry.CompileDataOfThisObject(out var operation);
if (operation != null)
{
operations.Add(operation);
}
}
}
//foreach( var geometry in mesh.Result.MeshData.RenderOperations )
//{
//}
FbxManager manager = null;
FbxIOSettings setting = null;
FbxExporter exporter = null;
FbxScene scene = null;
try
{
//init FBX manager
manager = FbxManager.Create();
setting = FbxIOSettings.Create(manager, "IOSRoot");
manager.SetIOSettings(setting);
scene = FbxScene.Create(manager, "scene");
scene.GetGlobalSettings().SetAxisSystem(new FbxAxisSystem(FbxAxisSystem.EPreDefinedAxisSystem.eMax));
scene.GetGlobalSettings().SetSystemUnit(new FbxSystemUnit(100));
//init FBX scene
for (int nOper = 0; nOper < operations.Count; nOper++)
{
var oper = operations[nOper];
//get data
Vector3F[] positions = null;
Vector3F[] normals = null;
var texCoords = new List <Vector2F[]>();
ColorValue[] colors = null;
Vector3F[] tangents = null;
Vector3F[] binormals = null;
//Position
{
if (oper.VertexStructure.GetElementBySemantic(VertexElementSemantic.Position, out VertexElement element) && element.Type == VertexElementType.Float3)
{
var buffer = oper.VertexBuffers[element.Source];
positions = buffer.ExtractChannel <Vector3F>(element.Offset);
}
}
//Normal
{
if (oper.VertexStructure.GetElementBySemantic(VertexElementSemantic.Normal, out VertexElement element) && element.Type == VertexElementType.Float3)
{
var buffer = oper.VertexBuffers[element.Source];
normals = buffer.ExtractChannel <Vector3F>(element.Offset);
}
}
//TexCoord
for (var channel = VertexElementSemantic.TextureCoordinate0; channel <= VertexElementSemantic.TextureCoordinate3; channel++)
{
if (oper.VertexStructure.GetElementBySemantic(channel, out VertexElement element) && element.Type == VertexElementType.Float2)
{
var buffer = oper.VertexBuffers[element.Source];
texCoords.Add(buffer.ExtractChannel <Vector2F>(element.Offset));
}
}
//Color
{
if (oper.VertexStructure.GetElementBySemantic(VertexElementSemantic.Color0, out VertexElement element))
{
if (element.Type == VertexElementType.Float4)
{
var buffer = oper.VertexBuffers[element.Source];
var values = buffer.ExtractChannel <Vector4F>(element.Offset);
colors = new ColorValue[positions.Length];
int destIndex = 0;
foreach (var p in values)
{
colors[destIndex++] = p.ToColorValue();
}
}
else if (element.Type == VertexElementType.ColorABGR)
{
//!!!!check
var buffer = oper.VertexBuffers[element.Source];
var values = buffer.ExtractChannel <uint>(element.Offset);
colors = new ColorValue[positions.Length];
int destIndex = 0;
foreach (var p in values)
{
colors[destIndex++] = new ColorValue(ColorByte.FromABGR(p));
}
}
else if (element.Type == VertexElementType.ColorARGB)
{
//!!!!check
var buffer = oper.VertexBuffers[element.Source];
var values = buffer.ExtractChannel <uint>(element.Offset);
colors = new ColorValue[positions.Length];
int destIndex = 0;
foreach (var p in values)
{
colors[destIndex++] = new ColorValue(ColorByte.FromARGB(p));
}
}
}
}
//Tangent, Binormal
if (normals != null)
{
if (oper.VertexStructure.GetElementBySemantic(VertexElementSemantic.Tangent, out VertexElement element) && element.Type == VertexElementType.Float4)
{
var buffer = oper.VertexBuffers[element.Source];
var tangents4 = buffer.ExtractChannel <Vector4F>(element.Offset);
tangents = new Vector3F[tangents4.Length];
binormals = new Vector3F[tangents4.Length];
int destIndex = 0;
foreach (var p in tangents4)
{
tangents[destIndex] = p.ToVector3F();
binormals[destIndex] = Vector3F.Cross(p.ToVector3F(), normals[destIndex]) * p.W;
destIndex++;
}
}
}
//indices
int[] indices = null;
if (oper.IndexBuffer != null)
{
indices = oper.IndexBuffer.Indices;
}
//create geometry
var geometryName = "Geometry " + nOper.ToString();
var mesh = FbxMesh.Create(scene, geometryName);
mesh.InitControlPoints(positions.Length);
FbxLayerElementNormal elementNormals = null;
if (normals != null)
{
elementNormals = mesh.CreateElementNormal();
elementNormals.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint);
elementNormals.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
}
FbxLayerElementVertexColor elementColors = null;
if (colors != null)
{
elementColors = mesh.CreateElementVertexColor();
elementColors.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint);
elementColors.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
}
FbxLayerElementTangent elementTangents = null;
if (tangents != null)
{
elementTangents = mesh.CreateElementTangent();
elementTangents.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint);
elementTangents.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
}
FbxLayerElementBinormal elementBinormals = null;
if (binormals != null)
{
elementBinormals = mesh.CreateElementBinormal();
elementBinormals.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint);
elementBinormals.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
}
var uvElements = new List <FbxLayerElementUV>();
for (int uvIndex = 0; uvIndex < texCoords.Count; uvIndex++)
{
var pUVElement = mesh.CreateElementUV("texcoord" + uvIndex.ToString());
pUVElement.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint);
pUVElement.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
uvElements.Add(pUVElement);
}
for (int n = 0; n < positions.Length; n++)
{
mesh.SetControlPointAt(ToFbxVector4(positions[n]), n);
if (normals != null)
{
elementNormals.GetDirectArray().Add(ToFbxVector4(normals[n]));
}
for (int uvIndex = 0; uvIndex < texCoords.Count; uvIndex++)
{
var texCoord = texCoords[uvIndex][n];
texCoord.Y = 1.0f - texCoord.Y;
uvElements[uvIndex].GetDirectArray().Add(ToFbxVector2(texCoord));
}
if (colors != null)
{
elementColors.GetDirectArray().Add(ToFbxColor(colors[n]));
}
if (tangents != null)
{
elementTangents.GetDirectArray().Add(ToFbxVector4(tangents[n]));
}
if (binormals != null)
{
elementBinormals.GetDirectArray().Add(ToFbxVector4(binormals[n]));
}
}
if (normals != null)
{
mesh.GetLayer(0).SetNormals(elementNormals);
}
if (colors != null)
{
mesh.GetLayer(0).SetVertexColors(elementColors);
}
if (tangents != null)
{
mesh.GetLayer(0).SetTangents(elementTangents);
}
if (binormals != null)
{
mesh.GetLayer(0).SetBinormals(elementBinormals);
}
int polygonCount = indices.Length / 3;
for (int i = 0; i < polygonCount; i++)
{
mesh.BeginPolygon(-1, -1, -1, false);
for (int j = 0; j < 3; j++)
{
int currentIndex = i * 3 + j;
int vertexIndex = indices[currentIndex];
mesh.AddPolygon(vertexIndex);
}
mesh.EndPolygon();
}
var node = FbxNode.Create(scene, geometryName);
node.SetNodeAttribute(mesh);
scene.GetRootNode().AddChild(mesh.GetNode());
}
//save
exporter = FbxExporter.Create(manager, "");
if (!exporter.Initialize(realFileName, -1, manager.GetIOSettings()))
{
error = "Can't initialize FBX exporter.";
return(false);
}
if (!exporter.Export(scene))
{
error = "Export to FBX failed.";
return(false);
}
}
finally
{
try { scene?.Destroy(); } catch { }
try { exporter?.Destroy(); } catch { }
try { setting?.Destroy(); } catch { }
try { manager?.Destroy(); } catch { }
}
foreach (var op in operations)
{
op.DisposeBuffers();
}
error = "";
return(true);
}
/// <summary>
/// Export the mesh's normals, binormals and tangents using
/// layer 0.
/// </summary>
///
public void ExportNormalsEtc(MeshInfo mesh, FbxMesh fbxMesh)
{
/// Set the Normals on Layer 0.
FbxLayer fbxLayer = fbxMesh.GetLayer(0 /* default layer */);
if (fbxLayer == null)
{
fbxMesh.CreateLayer();
fbxLayer = fbxMesh.GetLayer(0 /* default layer */);
}
using (var fbxLayerElement = FbxLayerElementNormal.Create(fbxMesh, "Normals"))
{
fbxLayerElement.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint);
// TODO: normals for each triangle vertex instead of averaged per control point
//fbxNormalLayer.SetMappingMode (FbxLayerElement.eByPolygonVertex);
fbxLayerElement.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
// Add one normal per each vertex face index (3 per triangle)
FbxLayerElementArray fbxElementArray = fbxLayerElement.GetDirectArray();
for (int n = 0; n < mesh.Normals.Length; n++)
{
fbxElementArray.Add(new FbxVector4(mesh.Normals [n] [0],
mesh.Normals [n] [1],
mesh.Normals [n] [2]));
}
fbxLayer.SetNormals(fbxLayerElement);
}
/// Set the binormals on Layer 0.
using (var fbxLayerElement = FbxLayerElementBinormal.Create(fbxMesh, "Binormals"))
{
fbxLayerElement.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint);
// TODO: normals for each triangle vertex instead of averaged per control point
//fbxBinormalLayer.SetMappingMode (FbxLayerElement.eByPolygonVertex);
fbxLayerElement.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
// Add one normal per each vertex face index (3 per triangle)
FbxLayerElementArray fbxElementArray = fbxLayerElement.GetDirectArray();
for (int n = 0; n < mesh.Binormals.Length; n++)
{
fbxElementArray.Add(new FbxVector4(mesh.Binormals [n] [0],
mesh.Binormals [n] [1],
mesh.Binormals [n] [2]));
}
fbxLayer.SetBinormals(fbxLayerElement);
}
/// Set the tangents on Layer 0.
using (var fbxLayerElement = FbxLayerElementTangent.Create(fbxMesh, "Tangents"))
{
fbxLayerElement.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint);
// TODO: normals for each triangle vertex instead of averaged per control point
//fbxBinormalLayer.SetMappingMode (FbxLayerElement.eByPolygonVertex);
fbxLayerElement.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
// Add one normal per each vertex face index (3 per triangle)
FbxLayerElementArray fbxElementArray = fbxLayerElement.GetDirectArray();
for (int n = 0; n < mesh.Normals.Length; n++)
{
fbxElementArray.Add(new FbxVector4(mesh.Tangents [n] [0],
mesh.Tangents [n] [1],
mesh.Tangents [n] [2]));
}
fbxLayer.SetTangents(fbxLayerElement);
}
}
void PrintAttribute(FbxManager manager, FbxNodeAttribute attri)
{
FbxLayerElementVertexColor pp;
Log.Info("attri " + attri.GetName());
Log.Info("attri type " + Enum.GetName(typeof(FbxNodeAttribute.EType), attri.GetAttributeType()));
//attri.is
if (attri.GetAttributeType() == FbxNodeAttribute.EType.eMesh)
{
Type t = attri.GetType();
Log.Info("type name " + t.Name);
FbxMesh mesh = attri.GetNode().GetMesh();
//FbxMesh mesh = attri as FbxMesh;
if (mesh == null)
{
Log.Error("convert mesh failed!");
return;
}
Console.WriteLine($"mesh.GetMeshEdgeCount() = {mesh.GetMeshEdgeCount()}; mesh.GetPolygonCount() = {mesh.GetPolygonCount()}; mesh.GetPolygonVertexCount()={mesh.GetPolygonVertexCount()}; " +
$"mesh.GetTextureUVCount() {mesh.GetTextureUVCount()}; mesh.GetControlPointsCount()={mesh.GetControlPointsCount()}; mesh.GetElementTangentCount()={mesh.GetElementTangentCount()};" +
$" mesh.GetElementNormalCount()={mesh.GetElementNormalCount()}; mesh.GetElementVertexColorCount()={mesh.GetElementVertexColorCount()};" +
$"mesh.GetUVLayerCount() = {mesh.GetUVLayerCount()}; mesh.GetLayerCount() = {mesh.GetLayerCount()}");
var pts = mesh.GetControlPoints();
var ar = FbxVector4Array.frompointer(pts);
for (int i = 0; i < mesh.GetLayerCount(); i++)
{
var layer = mesh.GetLayer(i);
}
try
{
var v2 = new FbxVector2();
IntPtr mem = Marshal.AllocHGlobal(4);
FbxStringList lst = new FbxStringList();
//int nameCount = lst.GetCount();
mesh.GetUVSetNames(lst); //ToDo : что за List, расширяется ли он сам?
var name = lst.GetItemAt(0).mString.Buffer();
//var myBool = new _MyBool(mem);
//var res = mesh.GetPolygonVertexUV(0, 0, name, v2, myBool);
// var c0 = v2.at(0);
// var c2 = v2.at(1);
var fbxArV2 = new FbxArrayFbxVector2();
var fbxArI = new FbxArrayInt();
var res = mesh.GetPolygonVertexUVs(name, fbxArV2, fbxArI);
var ptr = fbxArV2.GetAt(2).mData;
double coord1 = FbxWrapperNative.DoubleArrayFunc_getitem(ptr, 0);
double coord2 = FbxWrapperNative.DoubleArrayFunc_getitem(ptr, 1);
var param = FbxWrapperNative.new_FbxLayerElementArrayTemplateIntPtrFunc();
res = mesh.GetMaterialIndices(param);
var param2 = FbxWrapperNative.FbxLayerElementArrayTemplateIntPtrFunc_value(param);
int count = param2.GetCount();
List <int> mind = new List <int>();
for (int i = 0; i < count; i++)
{
mind.Add(param2.GetAt(i));
}
//var vec = new FbxVector4Array(5);
//var res2 = mesh.GetPolygonVertexUVs("", , null);
bool res1 = mesh.GenerateTangentsData(0);
//bool res2 = mesh.GenerateTangentsDataForAllUVSets( );
var tCount = mesh.GetElementTangentCount();
var tang = mesh.GetElementTangent( );
var tangAr = tang.GetDirectArray();
int tC = tangAr.GetCount();
//int binCount = mesh.GetElementBinormalCount();
//var bin = mesh.GetElementBinormal().GetDirectArray().GetCount();
}
catch (Exception ex)
{
}
//var vertices = mesh.GetPolygonVertices();
//FbxMesh mesh;
//FbxLayerElementUV uv = mesh.GetElementUV();
//uv.GetDirectArray()
FbxLayerElementNormal normal = mesh.GetElementNormal();
//ToDo
//DirectArrayFbxVector4 array = normal.GetDirectArray();
var array = normal.GetDirectArray();
Log.Info("normal count " + array.GetCount());
//for (int i = 0; i < array.GetCount(); i++)
//{
// FbxVector4 v = array.GetAt(i);
// SWIGTYPE_p_double data = v.mData;
// DoubleArray d = DoubleArray.frompointer(data);
// PrintDoubleArray(d, 4);
//}
}
}
public bool SetBaseMesh(FbxMesh pMesh)
{
bool ret = fbx_wrapperPINVOKE.FbxSubDiv_SetBaseMesh(swigCPtr, FbxMesh.getCPtr(pMesh));
return(ret);
}
public void Scene_AddObjectWithSrcObjects_AddsAllSrcObjects()
{
// given:
var scene = new FbxScene("s");
var node = new FbxNode("n");
var m1 = new FbxMesh("m1");
var m2 = new FbxMesh("m2");
var v = new FbxVideo("v");
var c = new FbxCluster("c");
var n2 = new FbxNode("n2");
var c2 = new FbxCluster("c2");
node.ConnectSrcObject(m1);
node.ConnectSrcObject(m2);
node.ConnectSrcObject(v);
node.ConnectSrcObject(c);
c.ConnectSrcObject(n2);;
n2.ConnectSrcObject(c2);
// require:
Assert.AreEqual(3, scene.GetSrcObjectCount());
Assert.AreEqual(4, node.GetSrcObjectCount());
Assert.AreSame(m1, node.GetSrcObject(0));
Assert.AreSame(m2, node.GetSrcObject(1));
Assert.AreSame(v, node.GetSrcObject(2));
Assert.AreSame(c, node.GetSrcObject(3));
Assert.AreEqual(0, node.GetDstObjectCount());
Assert.Null(node.GetScene());
Assert.AreEqual(0, m1.GetSrcObjectCount());
Assert.AreEqual(1, m1.GetDstObjectCount());
Assert.AreSame(node, m1.GetDstObject(0));
Assert.Null(m1.GetScene());
Assert.AreEqual(0, m2.GetSrcObjectCount());
Assert.AreEqual(1, m2.GetDstObjectCount());
Assert.AreSame(node, m2.GetDstObject(0));
Assert.Null(m2.GetScene());
Assert.AreEqual(0, v.GetSrcObjectCount());
Assert.AreEqual(1, v.GetDstObjectCount());
Assert.AreSame(node, v.GetDstObject(0));
Assert.Null(v.GetScene());
Assert.AreEqual(1, c.GetSrcObjectCount());
Assert.AreSame(n2, c.GetSrcObject());;
Assert.AreEqual(1, c.GetDstObjectCount());
Assert.AreSame(node, c.GetDstObject(0));
Assert.Null(c.GetScene());
Assert.AreEqual(1, n2.GetSrcObjectCount());
Assert.AreSame(c2, n2.GetSrcObject());;
Assert.AreEqual(1, n2.GetDstObjectCount());
Assert.AreSame(c, n2.GetDstObject(0));
Assert.Null(n2.GetScene());
Assert.AreEqual(0, c2.GetSrcObjectCount());
Assert.AreEqual(1, c2.GetDstObjectCount());
Assert.AreSame(n2, c2.GetDstObject(0));
Assert.Null(c2.GetScene());
// when:
scene.ConnectSrcObject(node);
// then:
Assert.AreEqual(10, scene.GetSrcObjectCount());
Assert.AreSame(node, scene.GetSrcObject(3));
Assert.AreSame(m1, scene.GetSrcObject(4));
Assert.AreSame(m2, scene.GetSrcObject(5));
Assert.AreSame(v, scene.GetSrcObject(6));
Assert.AreSame(c, scene.GetSrcObject(7));
Assert.AreSame(n2, scene.GetSrcObject(8));
Assert.AreSame(c2, scene.GetSrcObject(9));
Assert.AreEqual(4, node.GetSrcObjectCount());
Assert.AreSame(m1, node.GetSrcObject(0));
Assert.AreSame(m2, node.GetSrcObject(1));
Assert.AreSame(v, node.GetSrcObject(2));
Assert.AreSame(c, node.GetSrcObject(3));
Assert.AreEqual(1, node.GetDstObjectCount());
Assert.AreSame(scene, node.GetDstObject(0));
Assert.AreSame(scene, node.GetScene());
Assert.AreEqual(0, m1.GetSrcObjectCount());
Assert.AreEqual(2, m1.GetDstObjectCount());
Assert.AreSame(node, m1.GetDstObject(0));
Assert.AreSame(scene, m1.GetDstObject(1));
Assert.AreSame(scene, m1.GetScene());
Assert.AreEqual(0, m2.GetSrcObjectCount());
Assert.AreEqual(2, m2.GetDstObjectCount());
Assert.AreSame(node, m2.GetDstObject(0));
Assert.AreSame(scene, m2.GetDstObject(1));
Assert.AreSame(scene, m2.GetScene());
Assert.AreEqual(0, v.GetSrcObjectCount());
Assert.AreEqual(2, v.GetDstObjectCount());
Assert.AreSame(node, v.GetDstObject(0));
Assert.AreSame(scene, v.GetDstObject(1));
Assert.AreSame(scene, v.GetScene());
Assert.AreEqual(1, c.GetSrcObjectCount());
Assert.AreSame(n2, c.GetSrcObject(0));
Assert.AreEqual(2, c.GetDstObjectCount());
Assert.AreSame(node, c.GetDstObject(0));
Assert.AreSame(scene, c.GetDstObject(1));
Assert.AreSame(scene, c.GetScene());
Assert.AreEqual(1, n2.GetSrcObjectCount());
Assert.AreSame(c2, n2.GetSrcObject());;
Assert.AreEqual(2, n2.GetDstObjectCount());
Assert.AreSame(c, n2.GetDstObject(0));
Assert.AreSame(scene, n2.GetDstObject(1));
Assert.AreSame(scene, n2.GetScene());
Assert.AreEqual(0, c2.GetSrcObjectCount());
Assert.AreEqual(2, c2.GetDstObjectCount());
Assert.AreSame(n2, c2.GetDstObject(0));
Assert.AreSame(scene, c2.GetDstObject(1));
Assert.AreSame(scene, c2.GetScene());
}
public void SetSubdivLevelMesh(int pLevel, FbxMesh pMesh)
{
fbx_wrapperPINVOKE.FbxSubDiv_SetSubdivLevelMesh(swigCPtr, pLevel, FbxMesh.getCPtr(pMesh));
}
protected override FbxScene CreateScene(FbxManager manager)
{
FbxScene scene = base.CreateScene(manager);
// Add normals, binormals, UVs, tangents and vertex colors to the cube
FbxMesh cubeMesh = scene.GetRootNode().GetChild(0).GetMesh();
// Add normals
/// Set the Normals on Layer 0.
FbxLayer fbxLayer = cubeMesh.GetLayer(0 /* default layer */);
if (fbxLayer == null)
{
cubeMesh.CreateLayer();
fbxLayer = cubeMesh.GetLayer(0 /* default layer */);
}
using (var fbxLayerElement = FbxLayerElementNormal.Create(cubeMesh, "Normals"))
{
fbxLayerElement.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint);
fbxLayerElement.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
// Add one normal per each vertex face index (3 per triangle)
FbxLayerElementArray fbxElementArray = fbxLayerElement.GetDirectArray();
// Assign the normal vectors in the same order the control points were defined
FbxVector4[] normals = { normalZPos, normalXPos, normalZNeg, normalXNeg, normalYPos, normalYNeg };
for (int n = 0; n < normals.Length; n++)
{
for (int i = 0; i < 4; i++)
{
fbxElementArray.Add(normals [n]);
}
}
fbxLayer.SetNormals(fbxLayerElement);
}
/// Set the binormals on Layer 0.
using (var fbxLayerElement = FbxLayerElementBinormal.Create(cubeMesh, "Binormals"))
{
fbxLayerElement.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint);
fbxLayerElement.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
// Add one normal per each vertex face index (3 per triangle)
FbxLayerElementArray fbxElementArray = fbxLayerElement.GetDirectArray();
for (int n = 0; n < cubeMesh.GetControlPointsCount(); n++)
{
fbxElementArray.Add(new FbxVector4(-1, 0, 1)); // TODO: set to correct values
}
fbxLayer.SetBinormals(fbxLayerElement);
}
/// Set the tangents on Layer 0.
using (var fbxLayerElement = FbxLayerElementTangent.Create(cubeMesh, "Tangents"))
{
fbxLayerElement.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint);
fbxLayerElement.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
// Add one normal per each vertex face index (3 per triangle)
FbxLayerElementArray fbxElementArray = fbxLayerElement.GetDirectArray();
for (int n = 0; n < cubeMesh.GetControlPointsCount(); n++)
{
fbxElementArray.Add(new FbxVector4(0, -1, 1)); // TODO: set to correct values
}
fbxLayer.SetTangents(fbxLayerElement);
}
// set the vertex colors
using (var fbxLayerElement = FbxLayerElementVertexColor.Create(cubeMesh, "VertexColors"))
{
fbxLayerElement.SetMappingMode(FbxLayerElement.EMappingMode.eByControlPoint);
fbxLayerElement.SetReferenceMode(FbxLayerElement.EReferenceMode.eDirect);
// Add one normal per each vertex face index (3 per triangle)
FbxLayerElementArray fbxElementArray = fbxLayerElement.GetDirectArray();
// make each vertex either black or white
for (int n = 0; n < cubeMesh.GetControlPointsCount(); n++)
{
fbxElementArray.Add(new FbxColor(n % 2, n % 2, n % 2));
}
fbxLayer.SetVertexColors(fbxLayerElement);
}
// set the UVs
using (var fbxLayerElement = FbxLayerElementUV.Create(cubeMesh, "UVSet"))
{
fbxLayerElement.SetMappingMode(FbxLayerElement.EMappingMode.eByPolygonVertex);
fbxLayerElement.SetReferenceMode(FbxLayerElement.EReferenceMode.eIndexToDirect);
// set texture coordinates per vertex
FbxLayerElementArray fbxElementArray = fbxLayerElement.GetDirectArray();
for (int n = 0; n < 8; n++)
{
fbxElementArray.Add(new FbxVector2(n % 2, 1)); // TODO: switch to correct values
}
// For each face index, point to a texture uv
FbxLayerElementArray fbxIndexArray = fbxLayerElement.GetIndexArray();
fbxIndexArray.SetCount(24);
for (int vertIndex = 0; vertIndex < 24; vertIndex++)
{
fbxIndexArray.SetAt(vertIndex, vertIndex % 8); // TODO: switch to correct values
}
fbxLayer.SetUVs(fbxLayerElement, FbxLayerElement.EType.eTextureDiffuse);
}
return(scene);
}
public bool EmulateNormalsByPolygonVertex(FbxMesh pMesh)
{
bool ret = FbxWrapperNativePINVOKE.FbxGeometryConverter_EmulateNormalsByPolygonVertex(swigCPtr, FbxMesh.getCPtr(pMesh));
return(ret);
}
protected override FbxScene CreateScene(FbxManager manager)
{
FbxScene scene = base.CreateScene(manager);
// Set the UVs
FbxMesh cubeMesh = scene.GetRootNode().GetChild(0).GetMesh();
FbxLayer fbxLayer = cubeMesh.GetLayer(0 /* default layer */);
if (fbxLayer == null)
{
cubeMesh.CreateLayer();
fbxLayer = cubeMesh.GetLayer(0 /* default layer */);
}
using (var fbxLayerElement = FbxLayerElementUV.Create(cubeMesh, "UVSet"))
{
fbxLayerElement.SetMappingMode(FbxLayerElement.EMappingMode.eByPolygonVertex);
fbxLayerElement.SetReferenceMode(FbxLayerElement.EReferenceMode.eIndexToDirect);
// set texture coordinates per vertex
FbxLayerElementArray fbxElementArray = fbxLayerElement.GetDirectArray();
for (int n = 0; n < 8; n++)
{
fbxElementArray.Add(new FbxVector2(n % 2, 1)); // TODO: switch to correct values
}
// For each face index, point to a texture uv
FbxLayerElementArray fbxIndexArray = fbxLayerElement.GetIndexArray();
fbxIndexArray.SetCount(24);
for (int vertIndex = 0; vertIndex < 24; vertIndex++)
{
fbxIndexArray.SetAt(vertIndex, vertIndex % 8); // TODO: switch to correct values
}
fbxLayer.SetUVs(fbxLayerElement, FbxLayerElement.EType.eTextureDiffuse);
}
// Create the material
var fbxMaterial = FbxSurfacePhong.Create(scene, m_materialName);
fbxMaterial.Diffuse.Set(new FbxColor(1, 1, 1));
fbxMaterial.Emissive.Set(new FbxColor(0.5, 0.1, 0.2));
fbxMaterial.Ambient.Set(new FbxDouble3(0.3, 0.4, 0));
fbxMaterial.BumpFactor.Set(0.6);
fbxMaterial.Specular.Set(new FbxDouble3(0.8, 0.7, 0.9));
// Create and add the texture
var fbxMaterialProperty = fbxMaterial.FindProperty(FbxSurfaceMaterial.sDiffuse);
Assert.IsNotNull(fbxMaterialProperty);
Assert.IsTrue(fbxMaterialProperty.IsValid());
var fbxTexture = FbxFileTexture.Create(fbxMaterial, FbxSurfaceMaterial.sDiffuse + "_Texture");
fbxTexture.SetFileName("/path/to/some/texture.jpg");
fbxTexture.SetTextureUse(FbxTexture.ETextureUse.eStandard);
fbxTexture.SetMappingType(FbxTexture.EMappingType.eUV);
fbxTexture.ConnectDstProperty(fbxMaterialProperty);
scene.GetRootNode().GetChild(0).AddMaterial(fbxMaterial);
return(scene);
}
public bool ComputeEdgeSmoothingFromPolygonSmoothing(FbxMesh pMesh)
{
bool ret = FbxWrapperNativePINVOKE.FbxGeometryConverter_ComputeEdgeSmoothingFromPolygonSmoothing__SWIG_1(swigCPtr, FbxMesh.getCPtr(pMesh));
return(ret);
}
public bool Init(FbxNode pNode, FbxMesh pMesh)
{
bool ret = FbxWrapperNativePINVOKE.FbxDeformationsEvaluator_Init(swigCPtr, FbxNode.getCPtr(pNode), FbxMesh.getCPtr(pMesh));
return(ret);
}
public bool SplitMeshPerMaterial(FbxMesh pMesh, bool pReplace)
{
bool ret = FbxWrapperNativePINVOKE.FbxGeometryConverter_SplitMeshPerMaterial(swigCPtr, FbxMesh.getCPtr(pMesh), pReplace);
return(ret);
}
public void TestBasics()
{
Assert.That(!string.IsNullOrEmpty(ModelExporter.GetVersionFromReadme()));
// Test GetOrCreateLayer
using (var fbxManager = FbxManager.Create()) {
var fbxMesh = FbxMesh.Create(fbxManager, "name");
var layer0 = ModelExporter.GetOrCreateLayer(fbxMesh);
Assert.That(layer0, Is.Not.Null);
Assert.That(ModelExporter.GetOrCreateLayer(fbxMesh), Is.EqualTo(layer0));
var layer5 = ModelExporter.GetOrCreateLayer(fbxMesh, layer: 5);
Assert.That(layer5, Is.Not.Null);
Assert.That(layer5, Is.Not.EqualTo(layer0));
}
// Test axis conversion: a x b in left-handed is the same as b x a
// in right-handed (that's why we need to flip the winding order).
var a = new Vector3(1, 0, 0);
var b = new Vector3(0, 0, 1);
var crossLeft = Vector3.Cross(a, b);
Assert.That(ModelExporter.DefaultMaterial);
// Test non-static functions.
using (var fbxManager = FbxManager.Create()) {
var fbxScene = FbxScene.Create(fbxManager, "scene");
var fbxNode = FbxNode.Create(fbxScene, "node");
var exporter = new ModelExporter();
// Test ExportMaterial: it exports and it re-exports
bool result = exporter.ExportMaterial(ModelExporter.DefaultMaterial, fbxScene, fbxNode);
Assert.IsTrue(result);
var fbxMaterial = fbxNode.GetMaterial(0);
Assert.That(fbxMaterial, Is.Not.Null);
result = exporter.ExportMaterial(ModelExporter.DefaultMaterial, fbxScene, fbxNode);
var fbxMaterial2 = fbxNode.GetMaterial(1);
Assert.AreEqual(fbxMaterial, fbxMaterial2);
// Test ExportTexture: it finds the same texture for the default-material (it doesn't create a new one)
var fbxMaterialNew = FbxSurfaceLambert.Create(fbxScene, "lambert");
exporter.ExportTexture(ModelExporter.DefaultMaterial, "_MainTex",
fbxMaterialNew, FbxSurfaceLambert.sBump);
Assert.AreEqual(
fbxMaterial.FindProperty(FbxSurfaceLambert.sDiffuse).GetSrcObject(),
fbxMaterialNew.FindProperty(FbxSurfaceLambert.sBump).GetSrcObject()
);
// Test ExportMesh: make sure we exported a mesh with welded vertices.
var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
var cubeNode = FbxNode.Create(fbxScene, "cube");
exporter.ExportMesh(cube.GetComponent <MeshFilter>().sharedMesh, cubeNode);
Assert.That(cubeNode.GetMesh(), Is.Not.Null);
Assert.That(cubeNode.GetMesh().GetControlPointsCount(), Is.EqualTo(8));
}
// Test exporting a skinned-mesh. Make sure it doesn't leak (it did at one point)
{
var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
var character = new GameObject();
var smr = character.AddComponent <SkinnedMeshRenderer>();
smr.sharedMesh = cube.GetComponent <MeshFilter>().sharedMesh;
var meshCount = Object.FindObjectsOfType <Mesh>().Length;
ModelExporter.ExportObject(GetRandomFbxFilePath(), character);
Assert.AreEqual(meshCount, Object.FindObjectsOfType <Mesh>().Length);
}
// Test euler to quaternion conversion
{
// EulerToQuaternionZXY
var v = new Vector3(50, 45, 190);
var quat = ModelExporter.EulerToQuaternionZXY(v);
var unityQuat = Quaternion.Euler(v);
Assert.That((float)quat.X, Is.EqualTo(unityQuat.x));
Assert.That((float)quat.Y, Is.EqualTo(unityQuat.y));
Assert.That((float)quat.Z, Is.EqualTo(unityQuat.z));
Assert.That((float)quat.W, Is.EqualTo(unityQuat.w));
// EulerToQuaternionXYZ
var fbxV = new FbxVector4(v.x, v.y, v.z);
var xyzQuat = ModelExporter.EulerToQuaternionXYZ(fbxV);
// get the vector from the quaternion
FbxAMatrix m = new FbxAMatrix();
m.SetR(fbxV);
var actualQuat = m.GetQ();
// since this quaternion is XYZ instead of ZXY, it should not match the quaternion
// created with EulerToQuaternionZXY
Assert.That(xyzQuat, Is.Not.EqualTo(quat));
Assert.That(xyzQuat, Is.EqualTo(actualQuat));
}
}
/// <summary>
/// Export GameObject's as a skinned mesh with bones
/// </summary>
protected void ExportSkinnedMesh(Animator unityAnimator, FbxScene fbxScene, FbxNode fbxParentNode)
{
GameObject unityGo = unityAnimator.gameObject;
SkinnedMeshRenderer unitySkin
= unityGo.GetComponentInChildren <SkinnedMeshRenderer> ();
if (unitySkin == null)
{
Debug.LogError("could not find skinned mesh");
return;
}
var meshInfo = GetSkinnedMeshInfo(unityGo);
if (meshInfo.renderer == null)
{
Debug.LogError("mesh has no renderer");
return;
}
// create an FbxNode and add it as a child of fbxParentNode
FbxNode fbxNode = FbxNode.Create(fbxScene, unityAnimator.name);
Dictionary <Transform, FbxNode> boneNodes
= new Dictionary <Transform, FbxNode> ();
// export skeleton
if (ExportSkeleton(meshInfo, fbxScene, fbxNode, ref boneNodes))
{
// export skin
FbxNode fbxMeshNode = ExportMesh(meshInfo, fbxScene, fbxNode);
FbxMesh fbxMesh = fbxMeshNode.GetMesh();
if (fbxMesh == null)
{
Debug.LogError("Could not find mesh");
return;
}
// bind mesh to skeleton
ExportSkin(meshInfo, fbxScene, fbxMesh, fbxMeshNode, boneNodes);
// add bind pose
ExportBindPose(fbxNode, fbxMeshNode, fbxScene, boneNodes);
fbxParentNode.AddChild(fbxNode);
NumNodes++;
if (Verbose)
{
Debug.Log(string.Format("exporting {0} {1}", "Skin", fbxNode.GetName()));
}
}
else
{
Debug.LogError("failed to export skeleton");
}
}
