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