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 AddFrame(ImportedFrame srcFrame, int destParentIdx)
{
odfFrame newFrame = odf.CreateFrame(srcFrame, Parser);
odf.CopyOrCreateUnknowns(newFrame, Parser);
AddFrame(newFrame, destParentIdx);
Parser.CollectObjectIDs();
}
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 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 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 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 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);
}
}
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);
}
}
}
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;
}
public void MergeFrame(ImportedFrame srcFrame, int destParentIdx)
{
odfFrame newFrame = odf.CreateFrame(srcFrame, Parser);
odf.CopyOrCreateUnknowns(newFrame, Parser);
MergeFrame(newFrame, destParentIdx);
}
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;
}
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);
}
