public void MergeFrame(ImportedFrame srcFrame, int destParentIdx, bool topFrameRescaling) { remBone newFrame = rem.CreateFrame(srcFrame); if (topFrameRescaling) { if (srcFrame.Parent != null) { newFrame.matrix *= Matrix.Scaling(1f, 1f, -1f); } else { foreach (remBone child in newFrame) { child.matrix *= Matrix.Scaling(1f, 1f, -1f); } } } if (srcFrame.Parent != null) { MergeFrame(newFrame, destParentIdx); } else { foreach (remBone child in newFrame) { MergeFrame(child, destParentIdx); } } }
private void ConvertFrames(Transform trans, ImportedFrame parent) { ImportedFrame frame = new ImportedFrame(); frame.Name = trans.m_GameObject.instance.m_Name; frame.InitChildren(trans.Count); Vector3 euler = FbxUtility.QuaternionToEuler(trans.m_LocalRotation); euler.Y *= -1; euler.Z *= -1; Quaternion mirroredRotation = FbxUtility.EulerToQuaternion(euler); frame.Matrix = Matrix.Scaling(trans.m_LocalScale) * Matrix.RotationQuaternion(mirroredRotation) * Matrix.Translation(-trans.m_LocalPosition.X, trans.m_LocalPosition.Y, trans.m_LocalPosition.Z); if (parent == null) { FrameList = new List <ImportedFrame>(); FrameList.Add(frame); } else { parent.AddChild(frame); } foreach (Transform child in trans) { ConvertFrames(child, frame); } }
public static Transform CreateTransformTree(Animator parser, ImportedFrame frame, Transform parent) { Transform trans = new Transform(parser.file); GameObject gameObj = new GameObject(parser.file); gameObj.m_Name = (string)frame.Name.Clone(); UniqueName(parser, gameObj); gameObj.AddLinkedComponent(trans); parser.m_Avatar.instance.AddBone(parent, trans); Vector3 t, s; Quaternion r; frame.Matrix.Decompose(out s, out r, out t); t.X *= -1; Vector3 euler = FbxUtility.QuaternionToEuler(r); euler.Y *= -1; euler.Z *= -1; trans.m_LocalRotation = FbxUtility.EulerToQuaternion(euler); trans.m_LocalPosition = t; trans.m_LocalScale = s; trans.InitChildren(frame.Count); for (int i = 0; i < frame.Count; i++) { trans.AddChild(CreateTransformTree(parser, frame[i], trans)); } return(trans); }
private void ExportMeshFrames(ImportedFrame rootFrame, List <ImportedFrame> meshFrames) { foreach (var meshFrame in meshFrames) { _context.ExportMeshFromFrame(rootFrame, meshFrame, _imported.MeshList, _imported.MaterialList, _imported.TextureList, _exportSkins, _exportAllUvsAsDiffuseMaps); } }
internal void ExportMeshFromFrame(ImportedFrame rootFrame, ImportedFrame meshFrame, List <ImportedMesh> meshList, List <ImportedMaterial> materialList, List <ImportedTexture> textureList, bool exportSkins) { var meshNode = _frameToNode[meshFrame]; var mesh = ImportedHelpers.FindMesh(meshFrame.Path, meshList); ExportMesh(rootFrame, materialList, textureList, meshNode, mesh, exportSkins); }
public void MergeFrame(ImportedFrame srcFrame, int destParentIdx) { odfFrame newFrame = odf.CreateFrame(srcFrame, Parser); odf.CopyOrCreateUnknowns(newFrame, Parser); MergeFrame(newFrame, destParentIdx); }
public void AddFrame(ImportedFrame srcFrame, int destParentIdx) { odfFrame newFrame = odf.CreateFrame(srcFrame, Parser); odf.CopyOrCreateUnknowns(newFrame, Parser); AddFrame(newFrame, destParentIdx); Parser.CollectObjectIDs(); }
public void AddFrame(ImportedFrame srcFrame, int destParentId, int meshMatOffset) { xxFrame newFrame = xx.CreateFrame(srcFrame); xx.CopyOrCreateUnknowns(newFrame, Parser.Frame, Parser.Format); MeshMatOffset(newFrame, meshMatOffset); AddFrame(newFrame, destParentId); }
public void ReplaceFrame(ImportedFrame srcFrame, int destParentIdx, bool deleteMorphs) { odfFrame newFrame = odf.CreateFrame(srcFrame, Parser); odf.CopyOrCreateUnknowns(newFrame, Parser); ReplaceFrame(newFrame, destParentIdx, deleteMorphs); Parser.CollectObjectIDs(); }
public void AddFrame(ImportedFrame srcFrame, int destParentIdx, bool topFrameRescaling) { remBone newFrame = rem.CreateFrame(srcFrame); if (topFrameRescaling) { if (srcFrame.Parent != null && destParentIdx < 0) { newFrame.matrix *= Matrix.Scaling(1f, 1f, -1f); } } AddFrame(newFrame, destParentIdx); }
public static remBone CreateFrame(ImportedFrame frame) { remBone remFrame = new remBone(frame.Count); remFrame.matrix = frame.Matrix; remFrame.name = new remId(frame.Name); for (int i = 0; i < frame.Count; i++) { remFrame.AddChild(CreateFrame(frame[i])); } return remFrame; }
public static remBone CreateFrame(ImportedFrame frame) { remBone remFrame = new remBone(frame.Count); remFrame.matrix = frame.Matrix; remFrame.name = new remId(frame.Name); for (int i = 0; i < frame.Count; i++) { remFrame.AddChild(CreateFrame(frame[i])); } return(remFrame); }
public static odfFrame CreateFrame(ImportedFrame frame, odfParser parser) { odfFrame newFrame = new odfFrame(new ObjectName(frame.Name, null), null, frame.Count); newFrame.MeshId = ObjectID.INVALID; newFrame.Matrix = frame.Matrix; for (int i = 0; i < frame.Count; i++) { newFrame.AddChild(CreateFrame(frame[i], parser)); } return(newFrame); }
public static xxFrame CreateFrame(ImportedFrame frame) { xxFrame xxFrame = new xxFrame(); xxFrame.Matrix = frame.Matrix; xxFrame.Bounds = new BoundingBox(); xxFrame.Name = frame.Name; xxFrame.InitChildren(frame.Count); for (int i = 0; i < frame.Count; i++) { xxFrame.AddChild(CreateFrame(frame[i])); } return xxFrame; }
private static void SearchHierarchy(ImportedFrame rootFrame, List <ImportedMesh> meshList, HashSet <string> exportFrames) { var frameStack = new Stack <ImportedFrame>(); frameStack.Push(rootFrame); while (frameStack.Count > 0) { var frame = frameStack.Pop(); var meshListSome = ImportedHelpers.FindMesh(frame.Path, meshList); if (meshListSome != null) { var parent = frame; while (parent != null) { exportFrames.Add(parent.Path); parent = parent.Parent; } var boneList = meshListSome.BoneList; if (boneList != null) { foreach (var bone in boneList) { if (!exportFrames.Contains(bone.Path)) { var boneParent = rootFrame.FindFrameByPath(bone.Path); while (boneParent != null) { exportFrames.Add(boneParent.Path); boneParent = boneParent.Parent; } } } } } for (var i = frame.Count - 1; i >= 0; i -= 1) { frameStack.Push(frame[i]); } } }
public void ReplaceFrame(ImportedFrame srcFrame, int destParentIdx, bool topFrameRescaling) { remBone newFrame = rem.CreateFrame(srcFrame); if (topFrameRescaling) { if (destParentIdx < 0) { foreach (remBone child in newFrame) { child.matrix *= Matrix.Scaling(1f, 1f, -1f); } } } ReplaceFrame(newFrame, destParentIdx); }
private ImportedFrame ConvertFrames(remBone frame) { ImportedFrame iFrame = new ImportedFrame(); iFrame.InitChildren(frame.Count); iFrame.Name = frame.name; iFrame.Matrix = frame.matrix; FrameList.Add(iFrame); foreach (remBone child in frame) { ImportedFrame iChild = ConvertFrames(child); iFrame.AddChild(iChild); } return(iFrame); }
internal void SetJointsNode(ImportedFrame rootFrame, HashSet <string> bonePaths, bool castToBone, float boneSize) { var frameStack = new Stack <ImportedFrame>(); frameStack.Push(rootFrame); while (frameStack.Count > 0) { var frame = frameStack.Pop(); if (_frameToNode.TryGetValue(frame, out var node)) { Debug.Assert(node != IntPtr.Zero); if (castToBone) { AsFbxSetJointsNode_CastToBone(_pContext, node, boneSize); } else { Debug.Assert(bonePaths != null); if (bonePaths.Contains(frame.Path)) { AsFbxSetJointsNode_BoneInPath(_pContext, node, boneSize); } else { AsFbxSetJointsNode_Generic(_pContext, node); } } } for (var i = frame.Count - 1; i >= 0; i -= 1) { frameStack.Push(frame[i]); } } }
public static void ReplaceAnimation(WorkspaceAnimation wsAnimation, List <ImportedFrame> wsSkeleton, reaParser parser, int resampleCount, bool linear, ReplaceAnimationMethod replaceMethod, int insertPos, bool negateQuaternionFlips) { Report.ReportLog("Replacing animation ..."); List <KeyValuePair <string, ImportedAnimationSampledTrack> > newTrackList = FbxUtility.CopySampledAnimation(wsAnimation, resampleCount, linear); reaANICsection animationNodeList = parser.ANIC; ImportedSampledAnimation iAnim = new ImportedSampledAnimation(); iAnim.TrackList = new List <ImportedAnimationSampledTrack>(animationNodeList.Count); Dictionary <string, ImportedAnimationSampledTrack> animationNodeDic = null; if (replaceMethod != ReplaceAnimationMethod.Replace) { animationNodeDic = new Dictionary <string, ImportedAnimationSampledTrack>(); foreach (reaAnimationTrack animationNode in animationNodeList) { ImportedFrame boneFrame = ImportedHelpers.FindFrame(animationNode.boneFrame, wsSkeleton[0]); bool isTopFrame = boneFrame != null && boneFrame.Parent == wsSkeleton[0]; ImportedAnimationSampledTrack iTrack = Plugins.REMConverter.ConvertTrack(animationNode, isTopFrame); iTrack.Name = animationNode.boneFrame; animationNodeDic.Add(animationNode.boneFrame, iTrack); iAnim.TrackList.Add(iTrack); } } FbxUtility.ReplaceAnimation(replaceMethod, insertPos, newTrackList, iAnim, animationNodeDic, negateQuaternionFlips); animationNodeList.ChildList.Clear(); foreach (var newTrack in iAnim.TrackList) { ImportedFrame boneFrame = ImportedHelpers.FindFrame(newTrack.Name, wsSkeleton[0]); bool isTopFrame = boneFrame != null && boneFrame.Parent == wsSkeleton[0]; reaAnimationTrack animationNode = Plugins.REMConverter.ConvertTrack(newTrack, isTopFrame); animationNodeList.AddChild(animationNode); } }
private void ConvertMeshes(List <remMesh> meshes, remParser parser) { MeshList = new List <ImportedMesh>(meshes.Count); MaterialList = new List <ImportedMaterial>(meshes.Count); TextureList = new List <ImportedTexture>(parser.MATC.Count); foreach (remMesh mesh in meshes) { ImportedMesh iMesh = new ImportedMesh(); MeshList.Add(iMesh); iMesh.BoneList = new List <ImportedBone>(); Dictionary <remId, byte> boneDic = new Dictionary <remId, byte>(); remSkin skin = rem.FindSkin(mesh.name, parser.SKIC); rem.Mesh convertedMesh = new rem.Mesh(mesh, skin); iMesh.SubmeshList = new List <ImportedSubmesh>(convertedMesh.Count); remBone meshFrame = rem.FindFrame(mesh.frame, parser.BONC.rootFrame); ImportedFrame iFrame = ImportedHelpers.FindFrame(mesh.frame, FrameList[0]); float s = (float)Math.Round(Math.Abs(meshFrame.matrix.M11), 5); iFrame.Name = iMesh.Name = mesh.name + (s != 1f ? "(Scale=" + s.ToString() + ")" : String.Empty); foreach (rem.Submesh submesh in convertedMesh) { ImportedSubmesh iSubmesh = new ImportedSubmesh(); iMesh.SubmeshList.Add(iSubmesh); remMaterial mat = rem.FindMaterial(submesh.MaterialName, parser.MATC); if (mat != null) { iSubmesh.Material = mat.name; ImportedMaterial iMat = ImportedHelpers.FindMaterial(iSubmesh.Material, MaterialList); if (iMat == null) { iMat = new ImportedMaterial(); MaterialList.Add(iMat); iMat.Name = iSubmesh.Material; iMat.Diffuse = new Color4(mat.diffuse); iMat.Ambient = new Color4(mat.ambient); iMat.Specular = new Color4(mat.specular); iMat.Emissive = new Color4(mat.emissive); iMat.Power = mat.specularPower; iMat.Textures = new string[4] { String.Empty, String.Empty, String.Empty, String.Empty }; if (mat.texture != null) { iMat.Textures[0] = mat.texture; if (ImportedHelpers.FindTexture(iMat.Textures[0], TextureList) == null) { try { ImportedTexture iTex = rem.ImportedTexture(mat.texture, parser.RemPath, true); TextureList.Add(iTex); } catch { Report.ReportLog("cant read texture " + iMat.Textures[0]); } } } } } List <Tuple <byte, float> >[] iSkin = new List <Tuple <byte, float> > [submesh.numVertices]; for (int i = 0; i < submesh.numVertices; i++) { iSkin[i] = new List <Tuple <byte, float> >(4); } List <remBoneWeights> boneList = submesh.BoneList; if (boneList != null) { if (iMesh.BoneList.Capacity < boneList.Count) { iMesh.BoneList.Capacity += boneList.Count; } foreach (remBoneWeights boneWeights in boneList) { byte idx; if (!boneDic.TryGetValue(boneWeights.bone, out idx)) { ImportedBone iBone = new ImportedBone(); iMesh.BoneList.Add(iBone); iBone.Name = boneWeights.bone; Vector3 scale, translate; Quaternion rotate; meshFrame.matrix.Decompose(out scale, out rotate, out translate); scale.X = Math.Abs(scale.X); scale.Y = Math.Abs(scale.Y); scale.Z = Math.Abs(scale.Z); iBone.Matrix = Matrix.Scaling(1f, 1f, -1f) * Matrix.Invert(meshFrame.matrix) * Matrix.Scaling(scale) * boneWeights.matrix; boneDic.Add(boneWeights.bone, idx = (byte)boneDic.Count); } for (int i = 0; i < boneWeights.numVertIdxWts; i++) { iSkin[boneWeights.vertexIndices[i]].Add(new Tuple <byte, float>(idx, boneWeights.vertexWeights[i])); } } } iSubmesh.VertexList = new List <ImportedVertex>(submesh.numVertices); for (int i = 0; i < submesh.numVertices; i++) { remVertex vert = submesh.VertexList[i]; ImportedVertex iVert = new ImportedVertex(); iSubmesh.VertexList.Add(iVert); iVert.Position = new Vector3(vert.Position.X, vert.Position.Z, -vert.Position.Y); iVert.Normal = new Vector3(vert.Normal.X, vert.Normal.Z, -vert.Normal.Y); iVert.UV = new float[] { vert.UV[0], vert.UV[1] }; iVert.BoneIndices = new byte[4]; iVert.Weights = new float[4]; for (int j = 0; j < 4; j++) { if (j < iSkin[i].Count) { Tuple <byte, float> vertIdxWeight = iSkin[i][j]; iVert.BoneIndices[j] = vertIdxWeight.Item1; iVert.Weights[j] = vertIdxWeight.Item2; } else { iVert.BoneIndices[j] = 0xFF; } } } iSubmesh.FaceList = rem.ImportedFaceList(submesh.FaceList); } } }
public static odfFrame CreateFrame(ImportedFrame frame, odfParser parser) { odfFrame newFrame = new odfFrame(new ObjectName(frame.Name, null), null, frame.Count); newFrame.MeshId = ObjectID.INVALID; newFrame.Matrix = frame.Matrix; for (int i = 0; i < frame.Count; i++) { newFrame.AddChild(CreateFrame(frame[i], parser)); } return newFrame; }
public static Transform CreateTransformTree(Animator parser, ImportedFrame frame, Transform parent) { Transform trans = new Transform(parser.file); GameObject gameObj = new GameObject(parser.file); gameObj.m_Name = (string)frame.Name.Clone(); UniqueName(parser, gameObj); gameObj.AddLinkedComponent(trans); parser.m_Avatar.instance.AddBone(parent, trans); Vector3 t, s; Quaternion r; frame.Matrix.Decompose(out s, out r, out t); t.X *= -1; Vector3 euler = FbxUtility.QuaternionToEuler(r); euler.Y *= -1; euler.Z *= -1; trans.m_LocalRotation = FbxUtility.EulerToQuaternion(euler); trans.m_LocalPosition = t; trans.m_LocalScale = s; trans.InitChildren(frame.Count); for (int i = 0; i < frame.Count; i++) { trans.AddChild(CreateTransformTree(parser, frame[i], trans)); } return trans; }
private ImportedFrame ConvertFrames(odfFrame frame) { ImportedFrame iFrame = new ImportedFrame(); iFrame.InitChildren(frame.Count); iFrame.Name = frame.Name; iFrame.Matrix = frame.Matrix; FrameList.Add(iFrame); foreach (odfFrame child in frame) { ImportedFrame iChild = ConvertFrames(child); iFrame.AddChild(iChild); } return iFrame; }
void InitFrames(ImportedFrame frame) { Frames.Add(frame); foreach (var child in frame) { InitFrames(child); } }
public void ReplaceFrame(ImportedFrame srcFrame, int destParentId) { throw new NotImplementedException(); }
private void ConvertFrames(Transform trans, ImportedFrame parent) { ImportedFrame frame = new ImportedFrame(); frame.Name = trans.m_GameObject.instance.m_Name; frame.InitChildren(trans.Count); Vector3 euler = FbxUtility.QuaternionToEuler(trans.m_LocalRotation); euler.Y *= -1; euler.Z *= -1; Quaternion mirroredRotation = FbxUtility.EulerToQuaternion(euler); frame.Matrix = Matrix.Scaling(trans.m_LocalScale) * Matrix.RotationQuaternion(mirroredRotation) * Matrix.Translation(-trans.m_LocalPosition.X, trans.m_LocalPosition.Y, trans.m_LocalPosition.Z); if (parent == null) { FrameList = new List<ImportedFrame>(); FrameList.Add(frame); } else { parent.AddChild(frame); } foreach (Transform child in trans) { ConvertFrames(child, frame); } }
public void MergeFrame(ImportedFrame srcFrame, int destParentId) { Transform destParent = destParentId >= 0 ? Frames[destParentId] : Parser.RootTransform; Transform newFrame = Operations.CreateTransformTree(Parser, srcFrame, destParent); Operations.CopyOrCreateUnknowns(newFrame, Parser.RootTransform); MergeFrame(newFrame, destParentId); }
private void ExportMesh(ImportedFrame rootFrame, List <ImportedMaterial> materialList, List <ImportedTexture> textureList, IntPtr frameNode, ImportedMesh importedMesh, bool exportSkins) { var boneList = importedMesh.BoneList; var totalBoneCount = 0; var hasBones = false; if (exportSkins && boneList?.Count > 0) { totalBoneCount = boneList.Count; hasBones = true; } var pClusterArray = IntPtr.Zero; try { if (hasBones) { pClusterArray = AsFbxMeshCreateClusterArray(totalBoneCount); foreach (var bone in boneList) { if (bone.Path != null) { var frame = rootFrame.FindFrameByPath(bone.Path); var boneNode = _frameToNode[frame]; var cluster = AsFbxMeshCreateCluster(_pContext, boneNode); AsFbxMeshAddCluster(pClusterArray, cluster); } else { AsFbxMeshAddCluster(pClusterArray, IntPtr.Zero); } } } var mesh = AsFbxMeshCreateMesh(_pContext, frameNode); var totalVertexCount = 0; foreach (var m in importedMesh.SubmeshList) { totalVertexCount += m.VertexList.Count; } AsFbxMeshInitControlPoints(mesh, totalVertexCount); if (importedMesh.hasNormal) { AsFbxMeshCreateElementNormal(mesh); } if (importedMesh.hasUV[0]) { AsFbxMeshCreateDiffuseUV(mesh, 0); } if (importedMesh.hasUV[1]) { AsFbxMeshCreateNormalMapUV(mesh, 1); } if (importedMesh.hasTangent) { AsFbxMeshCreateElementTangent(mesh); } if (importedMesh.hasColor) { AsFbxMeshCreateElementVertexColor(mesh); } AsFbxMeshCreateElementMaterial(mesh); var firstVertex = 0; foreach (var meshObj in importedMesh.SubmeshList) { var materialIndex = 0; var mat = ImportedHelpers.FindMaterial(meshObj.Material, materialList); if (mat != null) { var foundMat = _createdMaterials.FindIndex(kv => kv.Key == mat.Name); IntPtr pMat; if (foundMat >= 0) { pMat = _createdMaterials[foundMat].Value; } else { var diffuse = mat.Diffuse; var ambient = mat.Ambient; var emissive = mat.Emissive; var specular = mat.Specular; var reflection = mat.Reflection; pMat = AsFbxCreateMaterial(_pContext, mat.Name, in diffuse, in ambient, in emissive, in specular, in reflection, mat.Shininess, mat.Transparency); _createdMaterials.Add(new KeyValuePair <string, IntPtr>(mat.Name, pMat)); } materialIndex = AsFbxAddMaterialToFrame(frameNode, pMat); var hasTexture = false; foreach (var texture in mat.Textures) { var tex = ImportedHelpers.FindTexture(texture.Name, textureList); var pTexture = ExportTexture(tex); if (pTexture != IntPtr.Zero) { switch (texture.Dest) { case 0: case 1: case 2: case 3: { AsFbxLinkTexture(texture.Dest, pTexture, pMat, texture.Offset.X, texture.Offset.Y, texture.Scale.X, texture.Scale.Y); hasTexture = true; break; } default: break; } } } if (hasTexture) { AsFbxSetFrameShadingModeToTextureShading(frameNode); } } var vertexList = meshObj.VertexList; var vertexCount = vertexList.Count; for (var j = 0; j < vertexCount; j += 1) { var importedVertex = vertexList[j]; var vertex = importedVertex.Vertex; AsFbxMeshSetControlPoint(mesh, j + firstVertex, vertex.X, vertex.Y, vertex.Z); if (importedMesh.hasNormal) { var normal = importedVertex.Normal; AsFbxMeshElementNormalAdd(mesh, 0, normal.X, normal.Y, normal.Z); } for (var uvIndex = 0; uvIndex < 2; uvIndex += 1) { if (importedMesh.hasUV[uvIndex]) { var uv = importedVertex.UV[uvIndex]; AsFbxMeshElementUVAdd(mesh, uvIndex, uv[0], uv[1]); } } if (importedMesh.hasTangent) { var tangent = importedVertex.Tangent; AsFbxMeshElementTangentAdd(mesh, 0, tangent.X, tangent.Y, tangent.Z, tangent.W); } if (importedMesh.hasColor) { var color = importedVertex.Color; AsFbxMeshElementVertexColorAdd(mesh, 0, color.R, color.G, color.B, color.A); } if (hasBones && importedVertex.BoneIndices != null) { var boneIndices = importedVertex.BoneIndices; var boneWeights = importedVertex.Weights; for (var k = 0; k < 4; k += 1) { if (boneIndices[k] < totalBoneCount && boneWeights[k] > 0) { AsFbxMeshSetBoneWeight(pClusterArray, boneIndices[k], j + firstVertex, boneWeights[k]); } } } } foreach (var face in meshObj.FaceList) { var index0 = face.VertexIndices[0] + firstVertex; var index1 = face.VertexIndices[1] + firstVertex; var index2 = face.VertexIndices[2] + firstVertex; AsFbxMeshAddPolygon(mesh, materialIndex, index0, index1, index2); } firstVertex += vertexCount; } if (hasBones) { IntPtr pSkinContext = IntPtr.Zero; try { pSkinContext = AsFbxMeshCreateSkinContext(_pContext, frameNode); unsafe { var boneMatrix = stackalloc float[16]; for (var j = 0; j < totalBoneCount; j += 1) { if (!FbxClusterArray_HasItemAt(pClusterArray, j)) { continue; } var m = boneList[j].Matrix; CopyMatrix4x4(in m, boneMatrix); AsFbxMeshSkinAddCluster(pSkinContext, pClusterArray, j, boneMatrix); } } AsFbxMeshAddDeformer(pSkinContext, mesh); } finally { AsFbxMeshDisposeSkinContext(ref pSkinContext); } } } finally { AsFbxMeshDisposeClusterArray(ref pClusterArray); } }
internal void ExportFrame(List <ImportedMesh> meshList, List <ImportedFrame> meshFrames, ImportedFrame rootFrame) { var rootNode = AsFbxGetSceneRootNode(_pContext); Debug.Assert(rootNode != IntPtr.Zero); var nodeStack = new Stack <IntPtr>(); var frameStack = new Stack <ImportedFrame>(); nodeStack.Push(rootNode); frameStack.Push(rootFrame); while (nodeStack.Count > 0) { var parentNode = nodeStack.Pop(); var frame = frameStack.Pop(); var childNode = AsFbxExportSingleFrame(_pContext, parentNode, frame.Path, frame.Name, frame.LocalPosition, frame.LocalRotation, frame.LocalScale); if (meshList != null && ImportedHelpers.FindMesh(frame.Path, meshList) != null) { meshFrames.Add(frame); } _frameToNode.Add(frame, childNode); for (var i = frame.Count - 1; i >= 0; i -= 1) { nodeStack.Push(childNode); frameStack.Push(frame[i]); } } }
private void SetJointsNode(ImportedFrame rootFrame, HashSet <string> bonePaths, bool castToBone) { _context.SetJointsNode(rootFrame, bonePaths, castToBone, _boneSize); }
private ImportedFrame ImportFrame(Section section) { ImportedFrame frame = new ImportedFrame(); frame.InitChildren(0); if (section.name == null) { frame.Name = "no_name" + noNameCount; noNameCount++; } else { frame.Name = section.name; } List<bool> hasBonesList = new List<bool>(); SortedDictionary<string, byte> boneDic = new SortedDictionary<string, byte>(); ImportedMesh meshList = new ImportedMesh(); meshList.Name = frame.Name; meshList.BoneList = new List<ImportedBone>(); meshList.SubmeshList = new List<ImportedSubmesh>(); Matrix matrix = new Matrix(); foreach (Section child in section.children) { if (child.type == "FrameTransformMatrix") { LinkedListNode<object> node = child.data.First; for (int i = 0; i < 4; i++) { for (int j = 0; j < 4; j++) { matrix[i, j] = ConvertFloat(node.Value); node = node.Next; } } frame.Matrix = RHToLHMatrix(matrix); } else if (child.type == "Mesh") { ImportMesh(child, meshList, boneDic, hasBonesList); } else if (child.type == "Frame") { ImportedFrame childFrame = ImportFrame(child); if (childFrame != null) { frame.AddChild(childFrame); } } else { Report.ReportLog("Warning: unexpected section " + child.type); } } SetBones(meshList, hasBonesList); if (meshList.SubmeshList.Count > 0) { MeshList.Add(meshList); } if (matrix == null) { frame.Matrix = Matrix.Identity; } return frame; }
private ImportedFrame ImportNode(Document.Node node) { ImportedFrame frame = new ImportedFrame(); try { frame.Name = DecodeName(node.id); frame.Matrix = ProcessNodeMatrix(node); ImportedMesh meshList = new ImportedMesh(); meshList.Name = frame.Name; meshList.SubmeshList = new List<ImportedSubmesh>(); List<string> boneNames = new List<string>(255); List<Matrix> boneMatrices = new List<Matrix>(255); List<Document.InstanceGeometry> geometries = new List<Document.InstanceGeometry>(); List<Document.InstanceController> controllers = new List<Document.InstanceController>(); List<Document.InstanceNode> instanceNodes; ProcessNodeInstances(node, geometries, controllers, out instanceNodes); for (int i = 0; i < instanceNodes.Count; i++) { List<Document.InstanceNode> dummy; Document.Node instanceNode = (Document.Node)colladaDoc.dic[instanceNodes[i].url.Fragment]; if (ProcessNodeInstances(instanceNode, geometries, controllers, out dummy)) { ImportedFrame child = ImportNode(instanceNode); if (child != null) { frame.AddChild(child); } } for (int j = 0; j < dummy.Count; j++) { Report.ReportLog("Warning: instance node " + dummy[j].name + " wasn't processed"); } } if (node.children != null) { for (int i = 0; i < node.children.Count; i++) { List<Document.InstanceNode> dummy; if (ProcessNodeInstances(node.children[i], geometries, controllers, out dummy)) { ImportedFrame child = ImportNode(node.children[i]); if (child != null) { frame.AddChild(child); } } for (int j = 0; j < dummy.Count; j++) { Report.ReportLog("Warning: instance node " + dummy[j].name + " wasn't processed"); } } } int vertInfoIdx = 0; for (int i = 0; i < controllers.Count; i++) { ImportedSubmesh submesh = ImportController((Document.Controller)colladaDoc.dic[controllers[i].url.Fragment], boneNames, boneMatrices, ref vertInfoIdx); if (submesh != null) { SetMaterial(controllers[i], submesh); submesh.Index = meshList.SubmeshList.Count; meshList.SubmeshList.Add(submesh); } } for (int i = 0; i < geometries.Count; i++) { ImportedSubmesh submesh = ImportGeometry((Document.Geometry)colladaDoc.dic[geometries[i].url.Fragment], ref vertInfoIdx); if (submesh != null) { SetMaterial(geometries[i], submesh); submesh.Index = meshList.SubmeshList.Count; meshList.SubmeshList.Add(submesh); foreach (ImportedVertex vert in submesh.VertexList) { if (boneNames.Count > 0) { vert.BoneIndices = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF }; vert.Weights = new float[] { 1, 0, 0, 0 }; } else { vert.BoneIndices = new byte[4]; vert.Weights = new float[4]; } } } } if (meshList.SubmeshList.Count > 0) { meshList.BoneList = new List<ImportedBone>(boneNames.Count); for (int i = 0; i < boneNames.Count; i++) { string name = boneNames[i]; ImportedBone bone = new ImportedBone(); bone.Name = DecodeName(name); bone.Matrix = boneMatrices[i]; meshList.BoneList.Add(bone); } MeshList.Add(meshList); } } catch (Exception e) { Report.ReportLog("Error importing node " + node.id + ": " + e.Message); frame = null; } return frame; }