private static MFnSkinCluster FindSkinCluster(ref List <MFnSkinCluster> Clusters, MFnMesh Mesh)
{
// Search
foreach (var Skin in Clusters)
{
if (Skin.numOutputConnections == 0)
{
continue;
}
for (uint i = 0; i < Skin.numOutputConnections; i++)
{
var GeoPath = new MDagPath();
Skin.getPathAtIndex(i, GeoPath);
if (GeoPath.equalEqual(Mesh.dagPath))
{
return(Skin);
}
}
}
// None
return(null);
}
public void Create()
{
MItDag jointIterator = new MItDag(MItDag.TraversalType.kDepthFirst, MFn.Type.kJoint);
//Create Joints and collect their DAG Paths
short jointID = 0;
for (; !jointIterator.isDone; jointIterator.next())
{
MFnIkJoint ikJoint = new MFnIkJoint();
MDagPath jointDagPath = new MDagPath();
jointIterator.getPath(jointDagPath);
this.JointDagPaths.Add(jointDagPath);
ikJoint.setObject(jointDagPath);
MTransformationMatrix local = new MTransformationMatrix(ikJoint.transformationMatrix);
MTransformationMatrix inverseGlobal = new MTransformationMatrix(jointDagPath.inclusiveMatrixInverse);
this.Joints.Add(new SKLJoint(jointID, ikJoint.name, local, inverseGlobal));
this.JointIndices.Add(ELF.Hash(ikJoint.name), jointID);
jointID++;
}
//Set Joint parents
for (int i = 0; i < this.Joints.Count; i++)
{
MFnIkJoint ikJoint = new MFnIkJoint(this.JointDagPaths[i]);
if (ikJoint.parentCount == 1 && ikJoint.parent(0).apiType == MFn.Type.kJoint)
{
MFnIkJoint parentJoint = new MFnIkJoint(ikJoint.parent(0));
MDagPath parentDagPath = new MDagPath();
parentJoint.getPath(parentDagPath);
//Find index of parent
for (int j = 0; j < this.JointDagPaths.Count; j++)
{
if (parentDagPath.equalEqual(this.JointDagPaths[j]))
{
this.Joints[i].ParentID = (short)j;
}
}
}
else
{
this.Joints[i].ParentID = -1;
}
}
MGlobal.displayInfo("SKLFile:Create - Created SKL File");
}
public void Create(SKLFile skl)
{
MSelectionList currentSelection = MGlobal.activeSelectionList;
MItSelectionList currentSelectionIterator = new MItSelectionList(currentSelection, MFn.Type.kMesh);
MDagPath meshDagPath = new MDagPath();
if (currentSelectionIterator.isDone)
{
MGlobal.displayError("SKNFile:Create - No mesh selected!");
throw new Exception("SKNFile:Create - No mesh selected!");
}
else
{
currentSelectionIterator.getDagPath(meshDagPath);
currentSelectionIterator.next();
if (!currentSelectionIterator.isDone)
{
MGlobal.displayError("SKNFile:Create - More than one mesh selected!");
throw new Exception("SKNFile:Create - More than one mesh selected!");
}
}
MFnMesh mesh = new MFnMesh(meshDagPath);
//Find Skin Cluster
MPlug inMeshPlug = mesh.findPlug("inMesh");
MPlugArray inMeshConnections = new MPlugArray();
inMeshPlug.connectedTo(inMeshConnections, true, false);
if (inMeshConnections.length == 0)
{
MGlobal.displayError("SKNFile:Create - Failed to find Skin Cluster!");
throw new Exception("SKNFile:Create - Failed to find Skin Cluster!");
}
MPlug outputGeometryPlug = inMeshConnections[0];
MFnSkinCluster skinCluster = new MFnSkinCluster(outputGeometryPlug.node);
MDagPathArray influenceDagPaths = new MDagPathArray();
uint influenceCount = skinCluster.influenceObjects(influenceDagPaths);
MGlobal.displayInfo("SKNFile:Create - Influence Count: " + influenceCount);
//Get SKL Influence Indices
MIntArray sklInfluenceIndices = new MIntArray(influenceCount);
for (int i = 0; i < influenceCount; i++)
{
MDagPath jointDagPath = influenceDagPaths[i];
MGlobal.displayInfo(jointDagPath.fullPathName);
//Loop through Joint DAG Paths, if we find a math for the influence, write the index
for (int j = 0; j < skl.JointDagPaths.Count; j++)
{
if (jointDagPath.equalEqual(skl.JointDagPaths[j]))
{
MGlobal.displayInfo("Found coresponding DAG path");
sklInfluenceIndices[i] = j;
break;
}
}
}
//Add Influence indices to SKL File
MIntArray maskInfluenceIndex = new MIntArray(influenceCount);
for (int i = 0; i < influenceCount; i++)
{
maskInfluenceIndex[i] = i;
skl.Influences.Add((short)sklInfluenceIndices[i]);
}
MObjectArray shaders = new MObjectArray();
MIntArray polygonShaderIndices = new MIntArray();
mesh.getConnectedShaders(meshDagPath.isInstanced ? meshDagPath.instanceNumber : 0, shaders, polygonShaderIndices);
uint shaderCount = shaders.length;
if (shaderCount > 32) //iirc 32 is the limit of how many submeshes there can be for an SKN file
{
MGlobal.displayError("SKNFile:Create - You've exceeded the maximum limit of 32 shaders");
throw new Exception("SKNFile:Create - You've exceeded the maximum limit of 32 shaders");
}
MIntArray vertexShaders = new MIntArray();
ValidateMeshTopology(mesh, meshDagPath, polygonShaderIndices, ref vertexShaders, shaderCount);
//Get Weights
MFnSingleIndexedComponent vertexIndexedComponent = new MFnSingleIndexedComponent();
MObject vertexComponent = vertexIndexedComponent.create(MFn.Type.kMeshVertComponent);
MIntArray groupVertexIndices = new MIntArray((uint)mesh.numVertices);
for (int i = 0; i < mesh.numVertices; i++)
{
groupVertexIndices[i] = i;
}
vertexIndexedComponent.addElements(groupVertexIndices);
MDoubleArray weights = new MDoubleArray();
uint weightsInfluenceCount = 0;
skinCluster.getWeights(meshDagPath, vertexComponent, weights, ref weightsInfluenceCount);
//Check if vertices don't have more than 4 influences and normalize weights
for (int i = 0; i < mesh.numVertices; i++)
{
int vertexInfluenceCount = 0;
double weightSum = 0;
for (int j = 0; j < weightsInfluenceCount; j++)
{
double weight = weights[(int)(i * weightsInfluenceCount) + j];
if (weight != 0)
{
vertexInfluenceCount++;
weightSum += weight;
}
}
if (vertexInfluenceCount > 4)
{
MGlobal.displayError("SKNFile:Create - Mesh contains a vertex with more than 4 influences");
throw new Exception("SKNFile:Create - Mesh contains a vertex with more than 4 influences");
}
//Normalize weights
for (int j = 0; j < weightsInfluenceCount; j++)
{
weights[(int)(i * influenceCount) + j] /= weightSum;
}
}
List <MIntArray> shaderVertexIndices = new List <MIntArray>();
List <List <SKNVertex> > shaderVertices = new List <List <SKNVertex> >();
List <MIntArray> shaderIndices = new List <MIntArray>();
for (int i = 0; i < shaderCount; i++)
{
shaderVertexIndices.Add(new MIntArray());
shaderVertices.Add(new List <SKNVertex>());
shaderIndices.Add(new MIntArray());
}
MItMeshVertex meshVertexIterator = new MItMeshVertex(meshDagPath);
for (meshVertexIterator.reset(); !meshVertexIterator.isDone; meshVertexIterator.next())
{
int index = meshVertexIterator.index();
int shader = vertexShaders[index];
if (shader == -1)
{
MGlobal.displayWarning("SKNFile:Create - Mesh contains a vertex with no shader");
continue;
}
MPoint pointPosition = meshVertexIterator.position(MSpace.Space.kWorld);
Vector3 position = new Vector3((float)pointPosition.x, (float)pointPosition.y, (float)pointPosition.z);
MVectorArray normals = new MVectorArray();
MIntArray uvIndices = new MIntArray();
Vector3 normal = new Vector3();
byte[] weightIndices = new byte[4];
float[] vertexWeights = new float[4];
meshVertexIterator.getNormals(normals);
//Normalize normals
for (int i = 0; i < normals.length; i++)
{
normal.X += (float)normals[i].x;
normal.Y += (float)normals[i].y;
normal.Z += (float)normals[i].z;
}
normal.X /= normals.length;
normal.Y /= normals.length;
normal.Z /= normals.length;
//Get Weight Influences and Weights
int weightsFound = 0;
for (int j = 0; j < weightsInfluenceCount && weightsFound < 4; j++)
{
double weight = weights[(int)(index * weightsInfluenceCount) + j];
if (weight != 0)
{
weightIndices[weightsFound] = (byte)maskInfluenceIndex[j];
vertexWeights[weightsFound] = (float)weight;
weightsFound++;
}
}
//Get unique UVs
meshVertexIterator.getUVIndices(uvIndices);
if (uvIndices.length != 0)
{
List <int> seen = new List <int>();
for (int j = 0; j < uvIndices.length; j++)
{
int uvIndex = uvIndices[j];
if (!seen.Contains(uvIndex))
{
seen.Add(uvIndex);
float u = 0;
float v = 0;
mesh.getUV(uvIndex, ref u, ref v);
SKNVertex vertex = new SKNVertex(position, weightIndices, vertexWeights, normal, new Vector2(u, 1 - v));
vertex.UVIndex = uvIndex;
shaderVertices[shader].Add(vertex);
shaderVertexIndices[shader].append(index);
}
}
}
else
{
MGlobal.displayError("SKNFile:Create - Mesh contains a vertex with no UVs");
throw new Exception("SKNFile:Create - Mesh contains a vertex with no UVs");
}
}
//Convert from Maya indices to data indices
int currentIndex = 0;
MIntArray dataIndices = new MIntArray((uint)mesh.numVertices, -1);
for (int i = 0; i < shaderCount; i++)
{
for (int j = 0; j < shaderVertexIndices[i].length; j++)
{
int index = shaderVertexIndices[i][j];
if (dataIndices[index] == -1)
{
dataIndices[index] = currentIndex;
shaderVertices[i][j].DataIndex = currentIndex;
}
else
{
shaderVertices[i][j].DataIndex = dataIndices[index];
}
currentIndex++;
}
this.Vertices.AddRange(shaderVertices[i]);
}
MItMeshPolygon polygonIterator = new MItMeshPolygon(meshDagPath);
for (polygonIterator.reset(); !polygonIterator.isDone; polygonIterator.next())
{
int polygonIndex = (int)polygonIterator.index();
int shaderIndex = polygonShaderIndices[polygonIndex];
MIntArray indices = new MIntArray();
MPointArray points = new MPointArray();
polygonIterator.getTriangles(points, indices);
if (polygonIterator.hasUVsProperty)
{
MIntArray vertices = new MIntArray();
MIntArray newIndices = new MIntArray(indices.length, -1);
polygonIterator.getVertices(vertices);
for (int i = 0; i < vertices.length; i++)
{
int dataIndex = dataIndices[vertices[i]];
int uvIndex;
polygonIterator.getUVIndex(i, out uvIndex);
if (dataIndex == -1 || dataIndex >= this.Vertices.Count)
{
MGlobal.displayError("SKNFIle:Create - Data Index outside of range");
throw new Exception("SKNFIle:Create - Data Index outside of range");
}
for (int j = dataIndex; j < this.Vertices.Count; j++)
{
if (this.Vertices[j].DataIndex != dataIndex)
{
MGlobal.displayError("SKNFIle:Create - Can't find corresponding face vertex in data");
throw new Exception("SKNFIle:Create - Can't find corresponding face vertex in data");
}
else if (this.Vertices[j].UVIndex == uvIndex)
{
for (int k = 0; k < indices.length; k++)
{
if (indices[k] == vertices[i])
{
newIndices[k] = j;
}
}
break;
}
}
}
for (int i = 0; i < newIndices.length; i++)
{
shaderIndices[shaderIndex].append(newIndices[i]);
}
}
else
{
for (int i = 0; i < indices.length; i++)
{
shaderIndices[shaderIndex].append(dataIndices[indices[i]]);
}
}
}
uint startIndex = 0;
uint startVertex = 0;
for (int i = 0; i < shaderCount; i++)
{
MPlug shaderPlug = new MFnDependencyNode(shaders[i]).findPlug("surfaceShader");
MPlugArray plugArray = new MPlugArray();
shaderPlug.connectedTo(plugArray, true, false);
string name = new MFnDependencyNode(plugArray[0].node).name;
uint indexCount = shaderIndices[i].length;
uint vertexCount = shaderVertexIndices[i].length;
//Copy indices to SKLFile
for (int j = 0; j < indexCount; j++)
{
this.Indices.Add((ushort)shaderIndices[i][j]);
}
this.Submeshes.Add(new SKNSubmesh(name, startVertex, vertexCount, startIndex, indexCount));
startIndex += indexCount;
startVertex += vertexCount;
}
MGlobal.displayInfo("SKNFile:Create - Created SKN File");
}
