public bool LoadNodeTreeFromStreamRecursive(NullNodeTree nodeTree, NullMemoryStream stream)
{
nodeTree.Clear();
bool res = stream.ReadString(out nodeTree.NodeName);
res &= stream.ReadInt(out nodeTree.NodeHandle);
res &= stream.ReadInt(out nodeTree.GroupId);
bool nameHandleOnly = false;
res &= stream.ReadBool(out nameHandleOnly);
if (!nameHandleOnly)
{
res &= stream.ReadVector3(out Pos);
res &= stream.ReadQuaternion(out Quat);
}
int count;
res &= stream.ReadInt(out count);
nodeTree.SetNumChildren(count);
for (int i = 0; i < nodeTree.NumChildren; i++)
{
NullNodeTree node = nodeTree.Children[i];
res &= LoadNodeTreeFromStreamRecursive(node, stream);
}
return(res);
}
public NullNodeTree FindNode(string nodeName)
{
NullNodeTree result = null;
FindNodeRecursive(this, nodeName, ref result);
return(result);
}
public NullNodeTree FindNode(int boneId)
{
NullNodeTree result = null;
FindNodeRecursive(this, boneId, ref result);
return(result);
}
private void ConvertNodeTree(Transform bone, NullNodeTree nodeTree, Matrix4x4[] bindposes, Transform[] bones)
{
int index = GetBoneIndex(bones, bone);
if (index == -1)
{
return;
}
nodeTree.SetNodeHandle(index);
nodeTree.SetNodeName(bone.name);
nodeTree.SetPosition(bindposes[index].GetColumn(3));
nodeTree.SetQuaternion(bindposes[index].rotation);
int childCount = bone.childCount;
for (int i = 0; i < childCount; ++i)
{
Transform child = bone.GetChild(i);
NullNodeTree childNode = new NullNodeTree();
childNode.SetNodeHandle(-1);
ConvertNodeTree(child, childNode, bindposes, bones);
if (childNode.GetNodeHandle() != -1)
{
nodeTree.Children.Add(childNode);
}
}
}
public void DeleteNodeRecursive(NullNodeTree nodeTree)
{
if (nodeTree == null)
{
return;
}
for (int i = 0; i < nodeTree.NumChildren; i++)
{
NullNodeTree node = nodeTree.Children[i];
DeleteNodeRecursive(node);
}
nodeTree.Children.Clear();
}
public int GetNodeCountRecursive(NullNodeTree nodeTree)
{
if (nodeTree == null)
{
return(0);
}
int count = 1;
for (int i = 0; i < nodeTree.NumChildren; i++)
{
count += GetNodeCountRecursive(nodeTree.Children[i]);
}
return(count);
}
public void FindNodeRecursive(NullNodeTree node, int boneId, ref NullNodeTree result)
{
if (result != null)
{
return;
}
if (node.GetNodeHandle() == boneId)
{
result = node;
return;
}
for (int i = 0; i < node.GetChildrenCount(); i++)
{
FindNodeRecursive(node[i], boneId, ref result);
if (result != null)
{
break;
}
}
}
public void FindNodeRecursive(NullNodeTree node, string nodeName, ref NullNodeTree result)
{
if (result != null)
{
return;
}
if (node.GetNodeName().Equals(nodeName))
{
result = node;
return;
}
for (int i = 0; i < node.GetChildrenCount(); i++)
{
FindNodeRecursive(node[i], nodeName, ref result);
if (result != null)
{
break;
}
}
}
protected bool RotateNodeTree(NullNodeTree nodeTree, float angle)
{
if (nodeTree == null || nodeTree.GetNodeCount() == 0)
{
return(false);
}
NullNodeTree rootNode = nodeTree;
if (rootNode != null)
{
Vector3 pos = rootNode.GetPosition();
Vector3 newPos = Vector3.zero;
Quaternion quat = rootNode.GetQuaternion();
Quaternion newQuat = Quaternion.identity;
Vector3RotateCalculation(angle, pos, ref newPos, false);
QuaternionRotateCalculation(angle, quat, ref newQuat);
rootNode.SetTransform(newPos.x, newPos.y, newPos.z, newQuat.x, newQuat.y, newQuat.z, newQuat.w);
}
return(true);
}
public int SaveNodeTreeToStreamRecursive(NullNodeTree nodeTree, NullMemoryStream stream, bool namehandleOnly)
{
CurrentVersion = NullMeshFile.MESH_FILE_VERSION;
int size = stream.WriteString(nodeTree.NodeName);
size += stream.WriteInt(nodeTree.NodeHandle);
size += stream.WriteInt(nodeTree.GroupId);
size += stream.WriteBool(namehandleOnly);
if (!namehandleOnly)
{
size += stream.WriteVector3(Pos);
size += stream.WriteQuaternion(Quat);
}
size += stream.WriteInt(nodeTree.NumChildren);
for (int i = 0; i < nodeTree.NumChildren; i++)
{
NullNodeTree node = nodeTree.Children[i];
if (node != null)
{
size += SaveNodeTreeToStreamRecursive(node, stream, namehandleOnly);
}
}
return(size);
}
private void CreateSkeletonMesh()
{
NullMeshFile meshFile = new NullMeshFile(NullWorkingFlag.WF_SKELETON_MESHPIECE);
bool hadNormals = mVertexNormals.Length > 0;
bool hadTangents = mVertexTangents.Length > 0;
bool hadColors = mVertexColors.Length > 0;
bool hadUv = mVertexuvs.Length > 0;
NullMeshObject meshObject = meshFile.AppendSkinObject(NullPrimitiveType.MOT_INDEXED_PRIMITIVES, mVertexTriangles.Length, mVertexPoses.Length, true, true, true);
NullUVGroup uvGroup = hadUv ? meshObject.GetOrCreateUVGroup(UVType.UVT_DEFAULT, mVertexPoses.Length) : null;
int vertexCount = mVertexPoses.Length;
for (int i = 0; i < vertexCount; ++i)
{
meshObject.SetVertex(i, mVertexPoses[i]);
if (hadColors)
{
meshObject.SetVertexColor(i, Convert(mVertexColors[i]));
}
if (hadTangents)
{
meshObject.SetTangent(i, mVertexTangents[i]);
}
if (hadNormals)
{
meshObject.SetNormal(i, mVertexNormals[i]);
}
if (hadUv)
{
uvGroup.SetUV(i, mVertexuvs[i]);
}
}
for (int i = 0; i < mVertexTriangles.Length; i += 3)
{
int i1 = mVertexTriangles[i];
int i2 = mVertexTriangles[i + 1];
int i3 = mVertexTriangles[i + 2];
meshObject.SetTriangleIndex(i, new Vector3Int(i1, i2, i3));
}
// 骨骼数
NullNodeTree rootNode = meshFile.GetNodeTree();
ConvertNodeTree(mRootBone, rootNode, mBindposes, mBones);
// 权重绑定
NullSkeletonBinding skeletonBinding = meshFile.GetSkeletonBinding();
int pieceCount = 1; // 对应子模型，现在只限制一个子模型
skeletonBinding.SetSkeletonName(mMesh.name);
skeletonBinding.SetSkeletonBindingCount(pieceCount);
for (int i = 0; i < pieceCount; ++i)
{
NullSkeletonPiece skeletonPiece = skeletonBinding[i];
skeletonPiece.SetPieceHandle(i);
ConvertSkeletonPiece(skeletonPiece, mBoneweights);
}
string fileName = OutPutDir + "/" + Target.name + ".hxs";
using (NullMemoryStream stream = NullMemoryStream.WriteToFile(fileName))
{
meshFile.SaveToStream(stream);
}
}
