private bool SaveScene(String targetdir, FBXManager pSdkManager, FBXScene pScene)
{
bool lResult = FBXHelper.SaveScene(pSdkManager, pScene, targetdir);
FBXHelper.DestroySdkObjects(pSdkManager, lResult);
return(lResult);
}
public bool ExportSkinnedMeshToFBX(SkeletonAsset skeleton, MeshAsset mesh, int lodIndex, String targetdir, bool asOne)
{
FBXManager lSdkManager = new FBXManager();
FBXScene lScene = new FBXScene();
FBXHelper.InitializeSdkObjects(lSdkManager, lScene);
FBXNode SceneRoot = lScene.GetRootNode();
FBXNode lSkeletonRoot = CreateFbxSkeleton(skeleton, lScene);
SceneRoot.AddChild(lSkeletonRoot);
if (asOne)
{
FBXNode fbxMesh = CreateFbxMesh(mesh.lods[lodIndex], lScene);
CreateMeshSkinning(skeleton, mesh.lods[lodIndex], fbxMesh, lSkeletonRoot, lScene);
SceneRoot.AddChild(fbxMesh);
StoreRestPose(lScene, lSkeletonRoot, skeleton);
}
else
{
for (int i = 0; i < mesh.lods[lodIndex].sections.Count; i++)
{
FBXNode CurrentSectionMesh = CreateFbxMesh(mesh.lods[lodIndex].sections[i], lScene);
CreateMeshSkinning(skeleton, mesh.lods[lodIndex].sections[i], CurrentSectionMesh, lSkeletonRoot, lScene);
SceneRoot.AddChild(CurrentSectionMesh);
StoreBindPose(lScene, CurrentSectionMesh);
}
}
return(SaveScene(targetdir, lSdkManager, lScene));
}
public void ExportSkeletalMeshToFbx(MESkeletalMesh mesh, string meshName, string targetdir)
{
FBXManager lSdkManager = new FBXManager();
FBXScene lScene = new FBXScene();
FBXHelper.InitializeSdkObjects(lSdkManager, lScene);
FBXNode SceneRoot = lScene.GetRootNode();
FBXNode lSkeletonRoot = CreateFbxSkeleton(mesh.Bones, lScene);
SceneRoot.AddChild(lSkeletonRoot);
try
{
FBXNode fbxMesh = CreateFbxMesh(mesh, meshName, lScene);
CreateMeshSkinning(mesh, 0, fbxMesh, lSkeletonRoot, lScene);
SceneRoot.AddChild(fbxMesh);
//StoreRestPose(lScene, lSkeletonRoot, skeleton);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
bool lResult = FBXHelper.SaveScene(lSdkManager, lScene, targetdir);
FBXHelper.DestroySdkObjects(lSdkManager, lResult);
}
public FBXScene __deref__()
{
global::System.IntPtr cPtr = FBXImporterUnmanagedPINVOKE.FBXScenePtr___deref__(swigCPtr);
FBXScene ret = (cPtr == global::System.IntPtr.Zero) ? null : new FBXScene(cPtr, false);
return(ret);
}
public static void InitializeSdkObjects(string sceneName, out FBXManager pManager, out FBXScene pScene)
{
// The first thing to do is to create the FBX Manager which is the object allocator for almost all the classes in the SDK
pManager = FBXManager.Create();
if (pManager == null)
{
Debug.WriteLine("Error: Unable to create FBX Manager!");
Environment.Exit(1);
}
else
{
Debug.WriteLine("Autodesk FBX SDK version {0}", FBXManager.GetVersion(true));
}
// Create an IOSettings object. This object holds all import/export settings.
FBXIOSettings ios = FBXIOSettings.Create(pManager, "IOSRoot");
pManager.SetIOSettings(ios);
// Load plugins from the executable directory (optional)
pManager.LoadPluginsDirectory(Environment.CurrentDirectory, string.Empty);
// Create an FBX scene. This object holds most objects imported/exported from/to files.
pScene = FBXScene.Create(pManager, sceneName);
if (pScene == null)
{
Debug.WriteLine("Error: Unable to create FBX scene!\n");
Environment.Exit(1);
}
}
private void AddMorphToMesh(FBXScene pScene, FBXNode pFbxNode, List <Vector> morph)
{
FBXShape lShape = FBXShape.Create(pScene, "MorphShape");
FBXMesh mesh = (FBXMesh)pFbxNode.GetMesh();
int count = mesh.GetControlPointsCount();
lShape.InitControlPoints(count);
List <FBXVector4> lControlPoints = lShape.GetControlPoints();
for (int i = 0; i < count; i++)
{
FBXVector4 cp = new FBXVector4(morph[i].members[0] * exportScale,
morph[i].members[1] * exportScale,
morph[i].members[2] * exportScale,
0);
lControlPoints[i] = cp;
}
lShape.SetControlPoints(lControlPoints);
FBXBlendShape lBlendShape = FBXBlendShape.Create(pScene, "morph");
FBXBlendShapeChannel lBlendShapeChannel = FBXBlendShapeChannel.Create(pScene, "morphchannel");
mesh.AddDeformer(lBlendShape);
lBlendShape.AddBlendShapeChannel(lBlendShapeChannel);
lBlendShapeChannel.AddTargetShape(lShape);
}
private void StoreRestPose(FBXScene pScene, FBXNode pSkeletonRoot, SkeletonAsset Skeleton)
{
Dictionary <String, FBBone> pose = Skeleton.ModelBones;
FBXAMatrix lTransformMatrix = new FBXAMatrix();
FBXVector4 lT, lR, lS;
lS = new FBXVector4(1.0, 1.0, 1.0, 0);
FBXPose lPose = FBXPose.Create(pScene, "A Bind Pose");
lT = new FBXVector4();
lR = new FBXVector4();
lTransformMatrix.SetTRS(lT, lR, lS);
FBXNode lKFbxNode = pSkeletonRoot;
lPose.Add(lKFbxNode, lTransformMatrix);
foreach (string key in pose.Keys)
{
FBBone bonePose = pose[key];
FBXNode fbxBone = pSkeletonRoot.FindChild(key);
FBXVector4 Forward = new FBXVector4(bonePose.Forward.members[0], bonePose.Forward.members[1], bonePose.Forward.members[2], 0);
FBXVector4 Right = new FBXVector4(bonePose.Right.members[0], bonePose.Right.members[1], bonePose.Right.members[2], 0);
FBXVector4 Up = new FBXVector4(bonePose.Up.members[0], bonePose.Up.members[1], bonePose.Up.members[2], 0);
FBXVector4 Trans = new FBXVector4(bonePose.Location.members[0] * exportScale, bonePose.Location.members[1] * exportScale, bonePose.Location.members[2] * exportScale, 1);
FBXAMatrix boneTransform = new FBXAMatrix();
boneTransform.SetRow(0, Right);
boneTransform.SetRow(1, Up);
boneTransform.SetRow(2, Forward);
boneTransform.SetRow(3, Trans);
lPose.Add(fbxBone, boneTransform);
}
lPose.SetIsBindPose(true);
pScene.AddPose(lPose);
}
private void StoreBindPose(FBXScene pScene, FBXNode pMesh)
{
List <FBXNode> lClusteredFbxNodes = new List <FBXNode>();
int i, j;
FBXNodeAttribute att = pMesh.GetNodeAttribute();
if (pMesh != null && att != null)
{
int lSkinCount = 0;
int lClusterCount = 0;
switch (pMesh.GetNodeAttribute().GetAttributeType())
{
default:
break;
case NodeAttribType.eMesh:
case NodeAttribType.eNurbs:
case NodeAttribType.ePatch:
FBXGeometry geo = (FBXGeometry)att.ToGeometry();
lSkinCount = geo.GetDeformerCount(EDeformerType.eSkin);
for (i = 0; i < lSkinCount; ++i)
{
FBXSkin lSkin = geo.GetSkinDeformer(i);
lClusterCount += lSkin.GetClusterCount();
}
break;
}
if (lClusterCount != 0)
{
for (i = 0; i < lSkinCount; ++i)
{
FBXGeometry geo = (FBXGeometry)att.ToGeometry();
FBXSkin lSkin = geo.GetSkinDeformer(i);
lClusterCount = lSkin.GetClusterCount();
for (j = 0; j < lClusterCount; ++j)
{
FBXNode lClusterNode = lSkin.GetClusterLink(j);
AddNodeRecursively(lClusteredFbxNodes, lClusterNode);
}
}
lClusteredFbxNodes.Add(pMesh);
}
}
if (lClusteredFbxNodes.Count != 0)
{
FBXPose lPose = FBXPose.Create(pScene, "pose");
lPose.SetIsBindPose(true);
for (i = 0; i < lClusteredFbxNodes.Count; i++)
{
FBXNode lKFbxNode = lClusteredFbxNodes[i];
FBXAMatrix lBindMatrix = lKFbxNode.EvaluateGlobalTransform();
lPose.Add(lKFbxNode, lBindMatrix);
}
pScene.AddPose(lPose);
}
}
/// <summary>
///
/// </summary>
/// <param name="sceneInstance">The fbx scene</param>
private static void DisplayHierarachy(FBXScene sceneInstance)
{
if (sceneInstance == null)
{
throw new ArgumentNullException("The scene is invalid. Check and try again.");
}
FBXNode rootNode = sceneInstance.GetRootNode();
DisplayHierarchyRecursive(rootNode, 0);
}
private static void PerformTests(FBXScene scene)
{
if (scene == null)
{
throw new ArgumentNullException("The scene that was specified is either null or empty.");
}
DisplayHierarachy(scene);
DisplayMetaData(scene);
DisplayContent(scene);
}
private FBXNode CreateFbxMesh(MeshLodSection section, FBXScene pScene)
{
FBXMesh fbxMesh = FBXMesh.Create(pScene, section.matName);
FBXGeometryElementNormal lGeometryElementNormal = fbxMesh.CreateElementNormal();
lGeometryElementNormal.SetMappingMode(FBXWrapper.MappingMode.eByControlPoint);
FBXGeometryElementBinormal lGeometryElementBiNormal = fbxMesh.CreateElementBinormal();
lGeometryElementBiNormal.SetMappingMode(FBXWrapper.MappingMode.eByControlPoint);
FBXGeometryElementTangent lGeometryElementTangent = fbxMesh.CreateElementTangent();
lGeometryElementTangent.SetMappingMode(FBXWrapper.MappingMode.eByControlPoint);
fbxMesh.InitControlPoints(section.vertices.Count);
FBXGeometryElementMaterial lMaterialElement = fbxMesh.CreateElementMaterial();
lMaterialElement.SetMappingMode(FBXWrapper.MappingMode.eByPolygon);
lMaterialElement.SetReferenceMode(FBXWrapper.ReferenceMode.eIndexToDirect);
FBXGeometryElementUV lUVDiffuseElement = fbxMesh.CreateElementUV(section.matName);
lUVDiffuseElement.SetMappingMode(FBXWrapper.MappingMode.eByControlPoint);
lUVDiffuseElement.SetReferenceMode(FBXWrapper.ReferenceMode.eIndexToDirect);
lUVDiffuseElement.SetIndexArrayCount(section.vertices.Count);
for (int j = 0; j < section.vertices.Count; j++)
{
FBXVector4 position = new FBXVector4(section.vertices[j].position.members[0] * exportScale, section.vertices[j].position.members[1] * exportScale, section.vertices[j].position.members[2] * exportScale, 0);
FBXVector4 normal = new FBXVector4(section.vertices[j].normals.members[0], section.vertices[j].normals.members[1], section.vertices[j].normals.members[2], section.vertices[j].normals.members[3]);
FBXVector4 textCoords = new FBXVector4(section.vertices[j].texCoords.members[0], (-section.vertices[j].texCoords.members[1] + 1), 0, 0);
FBXVector4 bitangent = new FBXVector4(section.vertices[j].biTangents.members[0], section.vertices[j].biTangents.members[1], section.vertices[j].biTangents.members[2], section.vertices[j].biTangents.members[3]);
FBXVector4 tangent = new FBXVector4(section.vertices[j].tangents.members[0], section.vertices[j].tangents.members[1], section.vertices[j].tangents.members[2], section.vertices[j].tangents.members[3]);
fbxMesh.SetControlPoint(j, position);
lGeometryElementNormal.Add(normal);
lGeometryElementBiNormal.Add(bitangent);
lGeometryElementTangent.Add(tangent);
lUVDiffuseElement.Add(textCoords);
}
for (int j = 0; j < section.indicies.Count; j++)
{
if (j % 3 == 0)
{
fbxMesh.EndPolygon();
fbxMesh.BeginPolygon();
}
fbxMesh.AddPolygon(section.indicies[j]);
}
fbxMesh.EndPolygon();
FBXNode lMeshNode = FBXNode.Create(pScene, section.matName);
lMeshNode.SetNodeAttribute(fbxMesh);
lMeshNode.AddMaterial(pScene, section.matName);
return(lMeshNode);
}
public void Load()
{
LogMessage("Instantiating the FBX Manager...");
FBXManager managerInstance = ArcManagedFBX.FBXManager.Create();
if (string.IsNullOrEmpty(Filename))
{
throw new FileNotFoundException("The file that is being loaded in does not exist!");
}
if (!File.Exists(Filename))
{
throw new FileNotFoundException("The file that is being loaded was not found on disk.");
}
LogMessage("Instantiating the FBX Settings...");
FBXIOSettings settings = FBXIOSettings.Create(managerInstance, "IOSRoot");
managerInstance.SetIOSettings(settings);
LogMessage("Loading plugins directory...");
managerInstance.LoadPluginsDirectory(Environment.CurrentDirectory, "");
int fileMajorNumber = 0, fileMinorNumber = 0, fileRevisionNumber = 0;
LogMessage("Instantiating the Scene...");
FBXScene scene = FBXScene.Create(managerInstance, "My Scene");
FBXImporter importer = FBXImporter.Create(managerInstance, "");
// Instantiate the framework for the scene as required.
m_SceneFramework = new SceneFramework(scene);
LogMessage("Load the importer for the file '{0}'", Filename);
bool initializeResult = importer.Initialize(Filename, -1, managerInstance.GetIOSettings());
FBXManager.GetFileFormatVersion(ref fileMajorNumber, ref fileMinorNumber, ref fileRevisionNumber);
bool importResult = importer.Import(scene);
m_SceneFramework.Operation();
if (importResult)
{
PerformTests(scene);
}
else
{
LogError("Import failed. Nothing to do!");
}
}
private FBXNode CreateFbxSkeleton(List <MESkeletalMesh.BoneStruct> Bones, FBXScene pScene)
{
FBXSkeleton lSkeletonRootAttribute = FBXSkeleton.Create(pScene, "Skeleton");
lSkeletonRootAttribute.SetSkeletonType(FBXWrapper.SkelType.eRoot);
FBXNode lSkeletonRoot = FBXNode.Create(pScene, "Skeleton");
lSkeletonRoot.SetNodeAttribute(lSkeletonRootAttribute);
lSkeletonRoot.LclTranslation = new FBXVector4().ToList();
FBXNode FbxSkeletonRootNode = CreateFbxBone(0, Bones, pScene, lSkeletonRoot);
lSkeletonRoot.AddChild(FbxSkeletonRootNode);
return(lSkeletonRoot);
}
private FBXNode CreateFbxSkeleton(SkeletonAsset Skeleton, FBXScene pScene)
{
FBXSkeleton lSkeletonRootAttribute = FBXSkeleton.Create(pScene, "Skeleton");
lSkeletonRootAttribute.SetSkeletonType(FBXWrapper.SkelType.eRoot);
FBXNode lSkeletonRoot = FBXNode.Create(pScene, "Skeleton");
lSkeletonRoot.SetNodeAttribute(lSkeletonRootAttribute);
lSkeletonRoot.LclTranslation = new FBXVector4().ToList();
FBXNode FbxSkeletonRootNode = CreateFbxBone(Skeleton.RootBone, pScene, lSkeletonRoot);
lSkeletonRoot.AddChild(FbxSkeletonRootNode);
SetBoneTransform(Skeleton, lSkeletonRoot);
return(lSkeletonRoot);
}
private FBXNode CreateFbxBone(FBBone bone, FBXScene pScene, FBXNode parent)
{
FBXSkeleton lSkeletonLimbNodeAttribute1 = FBXSkeleton.Create(pScene, bone.Name);
lSkeletonLimbNodeAttribute1.SetSkeletonType(FBXWrapper.SkelType.eLimbNode);
lSkeletonLimbNodeAttribute1.SetSize(1.0);
FBXNode lSkeletonLimbNode1 = FBXNode.Create(pScene, bone.Name);
lSkeletonLimbNode1.SetNodeAttribute(lSkeletonLimbNodeAttribute1);
for (int i = 0; i < bone.Children.Count; i++)
{
FBBone childBone = bone.Children[i];
FBXNode fbxChildBone = CreateFbxBone(childBone, pScene, lSkeletonLimbNode1);
lSkeletonLimbNode1.AddChild(fbxChildBone);
}
return(lSkeletonLimbNode1);
}
/// <summary>
/// Display the information that is relevant to the scene (in the form of a documentinfo)
/// </summary>
/// <param name="instance">The instance that we are retrieving metadata for</param>
private static void DisplayMetaData(FBXScene instance)
{
if (instance == null)
{
throw new ArgumentNullException("The instance specified is either null or invalid.");
}
FBXDocumentInfo metaDataContainer = instance.GetSceneInfo();
if (metaDataContainer == null)
{
throw new ArgumentNullException("The FBXDocumentInfo instance is either null or invalid.");
}
// Output the contents of the metadata class.
Logger.LogMessage("Title: {0}", metaDataContainer.Title);
Logger.LogMessage("Subject: {0}", metaDataContainer.Subject);
Logger.LogMessage("Author: {0}", metaDataContainer.Author);
Logger.LogMessage("Keywords: {0}", metaDataContainer.Keywords);
Logger.LogMessage("Revision: {0}", metaDataContainer.Revision);
}
private void ExportGroupShapes(CSGGroup group, FBXScene fbxScene, FBXNode sceneNode, string groupName, FBXNode node)
{
CSGShapeArray childShapeList = group.GetShapes();
for (int shapeIndex = 0; shapeIndex < childShapeList.GetSize(); shapeIndex++)
{
// this little bit of weirdness is due to View3D and Paint3D not being able to have multiple shapes on the same node
// there may need to be an export option for this at some point
var subnode = node;
if (shapeIndex > 0)
{
string subGroupName = this.GetUniqueName(groupName + "_" + shapeIndex.ToString(), "group");
subnode = FBXNode.Create(sceneNode, subGroupName);
node.AddChild(subnode);
}
this.ExportShape(fbxScene, subnode, childShapeList.GetElement(shapeIndex));
subnode.SetShadingMode(ArcManagedFBX.Types.EShadingMode.eTextureShading);
}
}
private void ExportGroupRecursively(CSGGroup group, FBXScene fbxScene, FBXNode parentNode, FBXAnimLayer animationLayer, float keyFramesPerSecond)
{
string groupName = this.GetUniqueName(group.Name, "group");
var node = FBXNode.Create(parentNode, groupName);
parentNode.AddChild(node);
this.SetTransform(group, node);
this.ExportGroupAnimation(group, animationLayer, keyFramesPerSecond, node);
this.ExportGroupShapes(group, fbxScene, parentNode, groupName, node);
CSGGroupArray childGroupList = group.GetChildren();
for (int groupIndex = 0; groupIndex < childGroupList.GetSize(); groupIndex++)
{
this.ExportGroupRecursively(childGroupList.GetElement(groupIndex), fbxScene, node, animationLayer, keyFramesPerSecond);
}
}
public bool ExportMeshWithMorph(SkeletonAsset Skeleton, MeshAsset mesh, int lodIndex, List <Vector> morphVertex, List <Vector> morphBones, String targetdir)
{
FBXManager lSdkManager = new FBXManager();
FBXScene lScene = new FBXScene();
FBXHelper.InitializeSdkObjects(lSdkManager, lScene);
FBXNode SceneRoot = lScene.GetRootNode();
FBXNode fbxMesh = CreateFbxMesh(mesh.lods[lodIndex], lScene);
AddMorphToMesh(lScene, fbxMesh, morphVertex);
SceneRoot.AddChild(fbxMesh);
if (Skeleton != null)
{
FBXNode lSkeletonRoot = CreateFbxSkeleton(Skeleton, lScene);
CreateMeshSkinning(Skeleton, mesh.lods[lodIndex], fbxMesh, lSkeletonRoot, lScene);
UpdateSkeletonWithMorph(Skeleton, lSkeletonRoot, morphBones);
SceneRoot.AddChild(lSkeletonRoot);
StoreBindPose(lScene, fbxMesh);
}
return(SaveScene(targetdir, lSdkManager, lScene));
}
public bool ExportStaticMeshToFBX(MeshAsset mesh, int lodIndex, String targetdir, bool asOne)
{
FBXManager lSdkManager = new FBXManager();
FBXScene lScene = new FBXScene();
FBXHelper.InitializeSdkObjects(lSdkManager, lScene);
FBXNode SceneRoot = lScene.GetRootNode();
if (asOne)
{
FBXNode fbxMesh = CreateFbxMesh(mesh.lods[lodIndex], lScene);
SceneRoot.AddChild(fbxMesh);
}
else
{
for (int i = 0; i < mesh.lods[lodIndex].sections.Count; i++)
{
FBXNode CurrentSectionMesh = CreateFbxMesh(mesh.lods[lodIndex].sections[i], lScene);
SceneRoot.AddChild(CurrentSectionMesh);
}
}
return(SaveScene(targetdir, lSdkManager, lScene));
}
public void ExportMeshWithMorph(Unreal.BioMorphFace morph, int lodIndex, String targetdir)
{
FBXManager lSdkManager = new FBXManager();
FBXScene lScene = new FBXScene();
FBXHelper.InitializeSdkObjects(lSdkManager, lScene);
FBXNode SceneRoot = lScene.GetRootNode();
MESkeletalMesh mesh = morph.Apply();
FBXNode fbxMesh = CreateFbxMesh(mesh, morph.Name, lScene);
SceneRoot.AddChild(fbxMesh);
if (mesh.Bones != null)
{
FBXNode lSkeletonRoot = CreateFbxSkeleton(mesh.Bones, lScene);
CreateMeshSkinning(mesh, lodIndex, fbxMesh, lSkeletonRoot, lScene);
UpdateSkeletonWithMorph(morph, lSkeletonRoot);
SceneRoot.AddChild(lSkeletonRoot);
//StoreBindPose(lScene, fbxMesh);
}
bool lResult = FBXHelper.SaveScene(lSdkManager, lScene, targetdir);
FBXHelper.DestroySdkObjects(lSdkManager, lResult);
}
/// <summary>
/// The display content method
/// </summary>
/// <param name="sceneInstance">The scene that we are running on.</param>
private static void DisplayContent(FBXScene sceneInstance)
{
FBXNode rootNode = sceneInstance.GetRootNode();
if (rootNode != null)
{
// Iterate over the children in this node.
for (int index = 0; index < rootNode.GetChildCount(); index++)
{
var attributeType = rootNode.GetChild(index).GetNodeAttribute().GetAttributeType();
FBXNode nodeInstance = rootNode.GetChild(index);
FBXNodeAttribute attributeInstance = nodeInstance.GetNodeAttribute();
// Cast out the node object based on the type of the attribute.
switch (attributeType)
{
case EAttributeType.eMesh:
DisplayMesh((FBXMesh)attributeInstance);
break;
case EAttributeType.eCamera:
DisplayCamera((FBXCamera)attributeInstance);
break;
case EAttributeType.eLight:
DisplayLight((FBXLight)attributeInstance);
break;
case EAttributeType.eSkeleton:
DisplaySkeleton((FBXSkeleton)attributeInstance);
break;
}
}
}
}
private void ImportFBX(string path)
{
FBXManager man = FBXManager.Create();
FBXIOSettings io = FBXIOSettings.Create(man, "IOSRoot");
man.SetIOSettings(io);
FBXImporter fbx = FBXImporter.Create(man, "");
fbx.Initialize(path, -1, man.GetIOSettings());
FBXScene scene = FBXScene.Create(man, "importScene");
fbx.Import(scene);
fbx.Destroy();
var root = scene.GetRootNode();
for (int i = 0; i < root.GetChildCount(); i++)
{
var child = root.GetChild(i);
if (child.GetName() == "Root")
{
ParseNode(child, true);
break;
}
}
List <VMeshDataFile> lst_vmesh_data = new List <VMeshDataFile>();
VMeshDataFile cur_meshdata_file = null;
for (int i = 0; i < cmpndData.Count; i++)
{
var cmpnd = cmpndData[i];
for (uint lod = 0; lod < cmpnd.object_data.lods; lod++)
{
if (cur_meshdata_file == null || cmpnd.object_data.data[lod].vmeshref.NumIndex + cur_meshdata_file.ref_vertices > 0xFFFF)
{
cur_meshdata_file = new VMeshDataFile();
cur_meshdata_file.filename = UniqueName + lst_vmesh_data.Count + ".vms";
cur_meshdata_file.ref_vertices = 0;
cur_meshdata_file.vertices = 0;
cur_meshdata_file.meshes = 0;
lst_vmesh_data.Add(cur_meshdata_file);
}
cur_meshdata_file.ref_vertices += cmpnd.object_data.data[lod].vmeshref.NumIndex;
cur_meshdata_file.vertices += cmpnd.object_data.data[lod].vmeshref.NumVert;
cur_meshdata_file.meshes += cmpnd.object_data.data[lod].vmeshref.NumMeshes;
cmpnd.object_data.data[lod].vmeshref.VMeshLibId = Utilities.FLModelCRC(cur_meshdata_file.filename);
cmpnd.object_data.data[lod].vmeshdata = cur_meshdata_file;
}
cmpnd.object_data.file_name = UniqueName + "." + cmpnd.object_name + ".3db";
cmpndData.RemoveAt(i);
cmpndData.Insert(i, cmpnd);
}
foreach (var vmesh in lst_vmesh_data)
{
/*VMeshData vmeshdata = new VMeshData();
*
* switch (VertexType)
* {
* case ModelImportVertexType.Normals:
* vmeshdata.FlexibleVertexFormat = (ushort)(VMeshData.D3DFVF_XYZ | VMeshData.D3DFVF_NORMAL | VMeshData.D3DFVF_TEX1);
* break;
* case ModelImportVertexType.VertexColors:
* vmeshdata.FlexibleVertexFormat = (ushort)(VMeshData.D3DFVF_XYZ | VMeshData.D3DFVF_DIFFUSE | VMeshData.D3DFVF_TEX1);
* break;
* case ModelImportVertexType.VertexColorsNormals:
* vmeshdata.FlexibleVertexFormat = (ushort)(VMeshData.D3DFVF_XYZ | VMeshData.D3DFVF_DIFFUSE | VMeshData.D3DFVF_NORMAL | VMeshData.D3DFVF_DIFFUSE);
* break;
* case ModelImportVertexType.ExtraUVs:
* vmeshdata.FlexibleVertexFormat = (ushort)(VMeshData.D3DFVF_XYZ | VMeshData.D3DFVF_NORMAL | VMeshData.D3DFVF_TEX2);
* break;
* case ModelImportVertexType.TangentsBinormals:
* vmeshdata.FlexibleVertexFormat = (ushort)(VMeshData.D3DFVF_XYZ | VMeshData.D3DFVF_NORMAL | VMeshData.D3DFVF_TEX4);
* break;
* case ModelImportVertexType.ExtraUVsTangentsBinormals:
* vmeshdata.FlexibleVertexFormat = (ushort)(VMeshData.D3DFVF_XYZ | VMeshData.D3DFVF_NORMAL | VMeshData.D3DFVF_TEX5);
* break;
* }*/
const uint HEADER_SIZE = 2 * 4 + 4 * 2;
const uint MESH_HEADER_SIZE = 4 + 3 * 2 + 2;
const uint INDEX_SIZE = 2;
uint VERTEX_SIZE = 0;
switch (VertexType)
{
case ModelImportVertexType.Normals:
VERTEX_SIZE = 3 * 4 + 3 * 4 + 2 * 4;
break;
case ModelImportVertexType.VertexColors:
VERTEX_SIZE = 3 * 4 + 1 * 4 + 2 * 4;
break;
case ModelImportVertexType.VertexColorsNormals:
VERTEX_SIZE = 3 * 4 + 3 * 4 + 1 * 4 + 2 * 4;
break;
case ModelImportVertexType.ExtraUVs:
VERTEX_SIZE = 3 * 4 + 3 * 4 + 2 * 4 + 2 * 4;
break;
case ModelImportVertexType.TangentsBinormals:
VERTEX_SIZE = 3 * 4 + 3 * 4 + 2 * 4 + 3 * 4 + 3 * 4;
break;
case ModelImportVertexType.ExtraUVsTangentsBinormals:
VERTEX_SIZE = 3 * 4 + 3 * 4 + 2 * 4 + 2 * 4 + 3 * 4 + 3 * 4;
break;
}
int meshCount = 0;
int indicesCount = 0;
int verticesCount = 0;
foreach (var cmpnd in cmpndData)
{
for (int lod = 0; lod < cmpnd.object_data.lods; lod++)
{
if (cmpnd.object_data.data[lod].vmeshdata == vmesh)
{
meshCount += cmpnd.object_data.data[lod].meshes.Count;
foreach (var m in cmpnd.object_data.data[lod].meshes)
{
indicesCount += m.t.Length * 3;
verticesCount += m.v.Length;
}
}
}
}
byte[] data = new byte[HEADER_SIZE + MESH_HEADER_SIZE * meshCount + INDEX_SIZE * indicesCount + VERTEX_SIZE * verticesCount];
int pos = 0;
// write header
Utilities.WriteInt(data, 1, ref pos);
Utilities.WriteInt(data, 4, ref pos);
Utilities.WriteWord(data, (ushort)vmesh.meshes, ref pos);
Utilities.WriteWord(data, (ushort)vmesh.ref_vertices, ref pos);
ushort fvf = 0;
switch (VertexType)
{
case ModelImportVertexType.Normals:
fvf = 0x112;
break;
case ModelImportVertexType.VertexColors:
fvf = 0x142;
break;
case ModelImportVertexType.VertexColorsNormals:
fvf = 0x152;
break;
case ModelImportVertexType.ExtraUVs:
fvf = 0x212;
break;
case ModelImportVertexType.TangentsBinormals:
fvf = 0x412;
break;
case ModelImportVertexType.ExtraUVsTangentsBinormals:
fvf = 0x512;
break;
}
Utilities.WriteWord(data, fvf, ref pos);
Utilities.WriteWord(data, (ushort)vmesh.vertices, ref pos);
uint iMesh = 0;
uint iGlobalStartVertex = 0;
uint iGlobalStartIndex = 0;
// save mesh header data
foreach (var cmpnd in cmpndData)
{
for (int lod = 0; lod < cmpnd.object_data.lods; lod++)
{
if (cmpnd.object_data.data[lod].vmeshdata == vmesh)
{
cmpnd.object_data.data[lod].vmeshref.StartMesh = (ushort)iMesh;
cmpnd.object_data.data[lod].vmeshref.StartVert = (ushort)iGlobalStartVertex;
cmpnd.object_data.data[lod].vmeshref.StartIndex = (ushort)iGlobalStartIndex;
uint iStartVert = 0;
foreach (var m in cmpnd.object_data.data[lod].meshes)
{
Utilities.WriteDWord(data, Utilities.FLModelCRC(m.material_name), ref pos);
Utilities.WriteWord(data, (ushort)iStartVert, ref pos);
Utilities.WriteWord(data, (ushort)(iStartVert + m.nVerts - 1), ref pos);
Utilities.WriteWord(data, (ushort)(m.nTris * 3), ref pos);
Utilities.WriteWord(data, 0xCC, ref pos);
iStartVert += (uint)m.nVerts;
iGlobalStartIndex += (uint)m.nTris * 3;
iGlobalStartVertex += (uint)m.nVerts;
iMesh++;
}
}
}
}
// save indices
foreach (var cmpnd in cmpndData)
{
for (int lod = 0; lod < cmpnd.object_data.lods; lod++)
{
if (cmpnd.object_data.data[lod].vmeshdata == vmesh)
{
foreach (var m in cmpnd.object_data.data[lod].meshes)
{
foreach (var t in m.t)
{
Utilities.WriteWord(data, t.vertices[0], ref pos);
Utilities.WriteWord(data, t.vertices[1], ref pos);
Utilities.WriteWord(data, t.vertices[2], ref pos);
}
}
}
}
}
// save vertices
foreach (var cmpnd in cmpndData)
{
for (int lod = 0; lod < cmpnd.object_data.lods; lod++)
{
if (cmpnd.object_data.data[lod].vmeshdata == vmesh)
{
foreach (var m in cmpnd.object_data.data[lod].meshes)
{
foreach (var v in m.v)
{
Utilities.WriteFloat(data, v.vert.X, ref pos);
Utilities.WriteFloat(data, v.vert.Y, ref pos);
Utilities.WriteFloat(data, v.vert.Z, ref pos);
if (VertexType != ModelImportVertexType.VertexColors)
{
Utilities.WriteFloat(data, v.normal.X, ref pos);
Utilities.WriteFloat(data, v.normal.Y, ref pos);
Utilities.WriteFloat(data, v.normal.Z, ref pos);
}
if (VertexType == ModelImportVertexType.VertexColors || VertexType == ModelImportVertexType.VertexColorsNormals)
{
Utilities.WriteDWord(data, v.diffuse, ref pos);
}
Utilities.WriteFloat(data, v.uv.X, ref pos);
Utilities.WriteFloat(data, v.uv.Y, ref pos);
if (VertexType == ModelImportVertexType.ExtraUVs || VertexType == ModelImportVertexType.ExtraUVsTangentsBinormals)
{
Utilities.WriteFloat(data, v.uv2.X, ref pos);
Utilities.WriteFloat(data, v.uv2.Y, ref pos);
}
if (VertexType == ModelImportVertexType.ExtraUVsTangentsBinormals || VertexType == ModelImportVertexType.TangentsBinormals)
{
Utilities.WriteFloat(data, v.tangent.X, ref pos);
Utilities.WriteFloat(data, v.tangent.Y, ref pos);
Utilities.WriteFloat(data, v.tangent.Z, ref pos);
Utilities.WriteFloat(data, v.binormal.X, ref pos);
Utilities.WriteFloat(data, v.binormal.Y, ref pos);
Utilities.WriteFloat(data, v.binormal.Z, ref pos);
}
}
}
}
}
}
TreeNode vmeshnode = CreateNode(vmesh.filename);
vmeshlib.Nodes.Add(vmeshnode);
TreeNode vmeshdatanode = CreateNode("VMeshData", data);
vmeshnode.Nodes.Add(vmeshdatanode);
}
uint iTotalVWireIndices = 0;
if (Wireframe)
{
}
TreeNode consnode = CreateNode("Cons");
cmpnd.Nodes.Add(consnode);
if (rev.Parts.Count > 0)
{
TreeNode revnode = CreateNode("Rev", rev.GetBytes());
consnode.Nodes.Add(revnode);
}
if (pris.Parts.Count > 0)
{
TreeNode prisnode = CreateNode("Pris", pris.GetBytes());
consnode.Nodes.Add(prisnode);
}
if (fix.Parts.Count > 0)
{
TreeNode fixnode = CreateNode("Fix", fix.GetBytes());
consnode.Nodes.Add(fixnode);
}
foreach (var cmpnd in cmpndData)
{
// Cmpnd child node
{
TreeNode cmpndnode = CreateNode(cmpnd.name);
this.cmpnd.Nodes.Add(cmpndnode);
TreeNode file_name = CreateNode("File name", Encoding.ASCII.GetBytes(cmpnd.object_data.file_name + "\u0000"));
TreeNode index = CreateNode("Index", BitConverter.GetBytes(cmpnd.index));
TreeNode object_name = CreateNode("Object name", Encoding.ASCII.GetBytes(cmpnd.object_name + "\u0000"));
cmpndnode.Nodes.Add(file_name);
cmpndnode.Nodes.Add(index);
cmpndnode.Nodes.Add(object_name);
}
// Root child node
{
TreeNode threedbnode = CreateNode(cmpnd.object_data.file_name);
rootCMP.Nodes.Add(threedbnode);
if (Wireframe)
{
}
TreeNode multilevel = CreateNode("MultiLevel");
threedbnode.Nodes.Add(multilevel);
if (cmpnd.object_data.lods > 1)
{
byte[] data = new byte[4 * cmpnd.object_data.lods];
int pos = 0;
Utilities.WriteFloat(data, 0.0f, ref pos);
for (int lod = 1; lod < cmpnd.object_data.lods; lod++)
{
Utilities.WriteFloat(data, (float)Math.Pow(10.0f, (float)(lod + 1)), ref pos);
}
Utilities.WriteFloat(data, 1000000.0f, ref pos);
TreeNode switch2 = CreateNode("Switch2", data);
multilevel.Nodes.Add(switch2);
}
for (int lod = 0; lod < cmpnd.object_data.lods; lod++)
{
TreeNode levelnode = CreateNode("Level" + lod);
multilevel.Nodes.Add(levelnode);
TreeNode vmeshpart = CreateNode("VMeshPart");
levelnode.Nodes.Add(vmeshpart);
TreeNode vmeshref = CreateNode("VMeshRef", cmpnd.object_data.data[lod].vmeshref.GetBytes());
vmeshpart.Nodes.Add(vmeshref);
}
}
}
}
void FbxsdkLoadAnimations(FBXScene scene, AnimationClipCreateInfo[] clips)
{
const double FRAMES_PER_SECOND = 30;
if (clips == null) return;
List<FBXNode> fbxNodeList = new List<FBXNode>();
FbxsdkFindAllAnimatedNodes(scene, scene.GetRootNode(), fbxNodeList);
if (fbxNodeList.Count == 0)
{
Debug.Log("Don't have animation data");
return;
}
foreach (var clipCreateInfo in clips)
{
var start = clipCreateInfo.Start;
var frameCount = clipCreateInfo.End - start + 1;
var clip = new AnimationClip();
clip.Name = clipCreateInfo.Name;
clip.SecondsPerFrame = 1 / FRAMES_PER_SECOND;
clip.Duration = frameCount / FRAMES_PER_SECOND;
foreach (var fbxNode in fbxNodeList)
{
var channel = new AnimationNodeChannel(frameCount);
channel.Clip = clip;
for (int i = 0; i < frameCount; ++i)
{
channel.Frames[i] = FbxsdkConvertMatrix(fbxNode.EvaluateLocalTransform(start + i));
}
clip.Channels[fbxNode.GetName()] = channel;
}
AnimationClips[clip.Name] = clip;
}
}
void FbxsdkFindAllAnimatedNodes(FBXScene scene, FBXNode node, List<FBXNode> outputCollection)
{
if(scene.HasCurve(node))
outputCollection.Add(node);
for(int i=0;i<node.GetChildCount();++i)
{
FbxsdkFindAllAnimatedNodes(scene, node.GetChild(i), outputCollection);
}
}
public SceneFramework(FBXScene sceneInstance)
{
m_SceneInstance = sceneInstance;
}
public SceneFramework(FBXScene sceneInstance)
{
m_SceneInstance = sceneInstance;
}
public FBXScene __ref__()
{
FBXScene ret = new FBXScene(FBXImporterUnmanagedPINVOKE.FBXScenePtr___ref__(swigCPtr), false);
return(ret);
}
public FBXScenePtr(FBXScene p) : this(FBXImporterUnmanagedPINVOKE.new_FBXScenePtr__SWIG_1(FBXScene.getCPtr(p)), true)
{
}
// SkeletalMesh
private void CreateMeshSkinning(MESkeletalMesh mesh, int lod, FBXNode pFbxMesh, FBXNode pSkeletonRoot, FBXScene pScene)
{
var vg = GetVertexGroups(mesh, lod);
CreateMeshSkinning(vg, pFbxMesh, pSkeletonRoot, pScene);
}
// skinning
private void CreateMeshSkinning(Dictionary <string, List <VertexWeight> > vg, FBXNode pFbxMesh, FBXNode pSkeletonRoot, FBXScene pScene)
{
FBXSkin lFbxSkin = FBXSkin.Create(pScene, "");
FBXAMatrix lMeshMatTransform = pFbxMesh.EvaluateGlobalTransform();
foreach (string key in vg.Keys)
{
List <VertexWeight> bvg = vg[key];
FBXCluster lCluster = FBXCluster.Create(pScene, key);
FBXNode lFbxBone = pSkeletonRoot.FindChild(key);
if (lFbxBone != null)
{
lCluster.SetLink(lFbxBone);
foreach (VertexWeight v in bvg)
{
lCluster.AddControlPointIndex(v.vertexIndex, v.weight);
}
lFbxSkin.AddCluster(lCluster);
lCluster.SetTransformMatrix(lMeshMatTransform);
FBXAMatrix lBoneMatTransform = lFbxBone.EvaluateGlobalTransform();
lCluster.SetTransformLinkMatrix(lBoneMatTransform);
}
}
FBXGeometry lFbxMeshAtt = (FBXGeometry)pFbxMesh.GetNodeAttribute().ToGeometry();
if (lFbxMeshAtt != null)
{
lFbxMeshAtt.AddDeformer(lFbxSkin);
}
}
private FBXNode CreateFbxBone(int boneIndex, List <MESkeletalMesh.BoneStruct> Skeleton, FBXScene pScene, FBXNode parent)
{
MESkeletalMesh.BoneStruct bone = Skeleton[boneIndex];
string boneName = bone.BoneName;
FBXSkeleton lSkeletonLimbNodeAttribute1 = FBXSkeleton.Create(pScene, boneName);
lSkeletonLimbNodeAttribute1.SetSkeletonType(FBXWrapper.SkelType.eLimbNode);
lSkeletonLimbNodeAttribute1.SetSize(1.0);
FBXNode lSkeletonLimbNode1 = FBXNode.Create(pScene, boneName);
lSkeletonLimbNode1.SetNodeAttribute(lSkeletonLimbNodeAttribute1);
lSkeletonLimbNode1.LclTranslation = new List <double> {
bone.Position.X, -bone.Position.Y, bone.Position.Z
};
ME3Explorer.Unreal.Classes.SkeletalMeshOld.Quad boneQuad;
boneQuad.x = -bone.Orientation.X;
boneQuad.y = bone.Orientation.Y;
boneQuad.z = bone.Orientation.Z;
boneQuad.w = -bone.Orientation.W;
if (boneIndex == 0)
{
boneQuad.w = boneQuad.w * -1;
}
Rotator rot = QuatToRotator(boneQuad);
lSkeletonLimbNode1.LclRotation = new List <double> {
rot.Roll, rot.Pitch, rot.Yaw
};
var children = Skeleton.Where(b => b.Parent == boneIndex).ToList();
foreach (var childBone in children)
{
int childIndexInSkeleton = Skeleton.FindIndex(b => b.Name == childBone.Name);
if (childIndexInSkeleton != boneIndex)
{
FBXNode fbxChildBone = CreateFbxBone(childIndexInSkeleton, Skeleton, pScene, lSkeletonLimbNode1);
lSkeletonLimbNode1.AddChild(fbxChildBone);
}
}
return(lSkeletonLimbNode1);
}
private FBXNode CreateFbxMesh(MESkeletalMesh mesh, string mname, FBXScene pScene, float exportScale = 1.0f)
{
MESkeletalMesh.LODModelStruct lod = mesh.LODModels[0];
FBXMesh fbxMesh = FBXMesh.Create(pScene, mname);
FBXNode lMeshNode = FBXNode.Create(pScene, mname);
lMeshNode.SetNodeAttribute(fbxMesh);
FBXGeometryElementTangent lGeometryElementTangent = fbxMesh.CreateElementTangent();
lGeometryElementTangent.SetMappingMode(FBXWrapper.MappingMode.eByControlPoint);
FBXGeometryElementMaterial lMaterialElement = fbxMesh.CreateElementMaterial();
lMaterialElement.SetMappingMode(FBXWrapper.MappingMode.eByPolygon);
lMaterialElement.SetReferenceMode(FBXWrapper.ReferenceMode.eIndexToDirect);
fbxMesh.InitControlPoints(lod.NumVertices);
// init UV maps
FBXGeometryElementUV[] UVs = new FBXGeometryElementUV[lod.Sections.Count];
for (int s = 0; s < lod.Sections.Count; s++)
{
string matName = GetMatName(mesh, lod, s);
UVs[s] = fbxMesh.CreateElementUV(matName);
UVs[s].SetMappingMode(FBXWrapper.MappingMode.eByControlPoint);
}
// vertices
for (int j = 0; j < lod.VertexBufferGPUSkin.Vertices.Count; j++)
{
var vertex = lod.VertexBufferGPUSkin.Vertices[j];
FBXVector4 position = new FBXVector4(vertex.Position.X * exportScale, -vertex.Position.Y * exportScale, vertex.Position.Z * exportScale, 0);
FBXVector4 normal = new FBXVector4(vertex.TangentX, 0, vertex.TangentZ, 0);
fbxMesh.SetControlPoint(j, position);
lGeometryElementTangent.Add(normal);
// uvs
for (int s = 0; s < lod.Sections.Count; s++)
{
var sectionVerts = GetSectionVertices(mesh, 0, s);
if (sectionVerts.Contains(j))
{
FBXVector4 texCoords = new FBXVector4(vertex.U, 1 - vertex.V, 0, 0);
UVs[s].Add(texCoords);
}
else
{
UVs[s].Add(new FBXVector4(0, 0, 0, 0));
}
}
}
// faces & mats
for (int s = 0; s < lod.Sections.Count; s++)
{
int chunkId = lod.Sections[s].ChunkIndex;
var chunk = lod.Chunks[chunkId];
// mat
string matName = GetMatName(mesh, lod, s);
lMeshNode.AddMaterial(pScene, matName);
// faces
for (int j = 0; j < lod.Sections[s].NumTriangles; j++)
{
int baseI = lod.Sections[s].BaseIndex;
fbxMesh.BeginPolygon(s);
fbxMesh.AddPolygon(lod.IndexBuffer.Indexes[baseI + j * 3]);
fbxMesh.AddPolygon(lod.IndexBuffer.Indexes[baseI + j * 3 + 1]);
fbxMesh.AddPolygon(lod.IndexBuffer.Indexes[baseI + j * 3 + 2]);
fbxMesh.EndPolygon();
}
}
return(lMeshNode);
}
