bool Exporter::makeSkin(NiTriBasedGeomRef shape, INode *node, FaceGroup &grp, TimeValue t)
{
if (!mExportSkin)
return false;
if (grp.verts.empty())
return false;
//get the skin modifier
Modifier *mod = GetSkin(node);
if (!mod)
return false;
ISkin *skin = (ISkin *) mod->GetInterface(I_SKIN);
if (!skin)
return false;
ISkinContextData *skinData = skin->GetContextInterface(node);
if (!skinData)
return false;
if (grp.strips.empty())
strippify(grp);
// Create new call back to finish export
SkinInstance* si = new SkinInstance(this);
mPostExportCallbacks.push_back(si);
skin->GetSkinInitTM(node, si->bone_init_tm, false);
skin->GetSkinInitTM(node, si->node_init_tm, true);
si->shape = shape;
// Get bone references (may not actually exist in proper structure at this time)
int totalBones = skin->GetNumBones();
si->boneWeights.resize(totalBones);
si->boneList.resize(totalBones);
for (int i=0; i<totalBones; ++i) {
si->boneList[i] = getNode(skin->GetBone(i));
}
vector<int>& vidx = grp.vidx;
int nv = vidx.size();
for (int i=0; i<nv; ++i)
{
int vi = vidx[i];
int nbones = skinData->GetNumAssignedBones(vi);
for (int j=0; j<nbones; ++j)
{
SkinWeight sw;
sw.index = i;
sw.weight = skinData->GetBoneWeight(vi,j);
int boneIndex = skinData->GetAssignedBone(vi,j);
SkinInstance::SkinWeightList& weights = si->boneWeights[boneIndex];
weights.push_back(sw);
}
}
// remove unused bones
vector<NiNodeRef>::iterator bitr = si->boneList.begin();
SkinInstance::BoneWeightList::iterator switr = si->boneWeights.begin();
for (int i=0; i<totalBones; ++i) {
vector<SkinWeight> &weights = (*switr);
if (weights.empty())
{
bitr = si->boneList.erase(bitr);
switr = si->boneWeights.erase(switr);
}
else
{
++bitr, ++switr;
}
}
// Check for dismemberment
if (IsFallout3() || IsSkyrim()) {
Modifier *dismemberSkinMod = GetBSDismemberSkin(node);
if (dismemberSkinMod)
{
if (IBSDismemberSkinModifier *disSkin = (IBSDismemberSkinModifier *) dismemberSkinMod->GetInterface(I_BSDISMEMBERSKINMODIFIER)){
Tab<IBSDismemberSkinModifierData*> modData = disSkin->GetModifierData();
if (modData.Count() >= 1) {
IBSDismemberSkinModifierData* bsdsmd = modData[0];
si->SkinInstConstructor = BSDismemberSkinInstance::Create;
Tab<BSDSPartitionData> &flags = bsdsmd->GetPartitionFlags();
GenericNamedSelSetList &fselSet = bsdsmd->GetFaceSelList();
FaceMap fmap;
NiTriBasedGeomDataRef data = DynamicCast<NiTriBasedGeomData>(shape->GetData());
vector<Triangle> tris = data->GetTriangles();
for (int i=0; i<tris.size(); ++i) {
Triangle tri = tris[i];
fmap[ rotate(tri) ] = i;
}
// Build up list of partitions and face to partition map
si->partitions.resize(flags.Count());
si->facePartList.resize( grp.faces.size(), -1 );
for (int i=0; i<flags.Count(); ++i) {
BodyPartList& bp = si->partitions[i];
bp.bodyPart = (BSDismemberBodyPartType)flags[i].bodyPart;
bp.partFlag = (BSPartFlag)(flags[i].partFlag | PF_START_NET_BONESET);
BitArray& fSelect = fselSet[i];
for (int j=0; j<fSelect.GetSize(); ++j){
if ( fSelect[j] ) {
Triangle tri = grp.faces[grp.fidx[j]];
FaceMap::iterator fitr = fmap.find( rotate(tri) );
if (fitr != fmap.end())
si->facePartList[ (*fitr).second ] = i;
}
}
}
}
}
}
}
return true;
}
void SGP_MaxInterface::GetBoneGroup( Modifier *pModifier,
int nModifierType,
INode* pNode,
Mesh* pMesh,
int nVertexId,
BoneGroup& boneGroup )
{
if( !pMesh )
{
assert( false );
return;
}
if( nVertexId >= pMesh->numVerts )
{
assert( false );
return;
}
// static mesh
if( nModifierType == MODIFIER_NONE )
{
INode* pParent = pNode->GetParentNode();
if( pParent && ( IsBone( pParent ) || IsBipedBone( pParent ) ) )
{
Influence infl;
infl.fWeight = 1.0f;
strcpy( infl.szBoneName, pParent->GetName() );
boneGroup.AddInfluence( infl );
}
}
// check for physique modifier
else if( nModifierType == MODIFIER_PHYSIQUE )
{
assert( pModifier && "get bone group error, modifier is null" );
// create a physique export interface
IPhysiqueExport *pPhysiqueExport = (IPhysiqueExport *)pModifier->GetInterface(I_PHYINTERFACE);
if(pPhysiqueExport == NULL)
{
return;
}
// create a context export interface
IPhyContextExport *pContextExport = (IPhyContextExport *)pPhysiqueExport->GetContextInterface(pNode);
if(pContextExport == NULL)
{
pModifier->ReleaseInterface(I_PHYINTERFACE, pPhysiqueExport);
return;
}
// set the flags in the context export interface
pContextExport->ConvertToRigid(TRUE);
pContextExport->AllowBlending(TRUE);
// get the vertex export interface
IPhyVertexExport *pVertexExport = (IPhyVertexExport *)pContextExport->GetVertexInterface(nVertexId);
if(pVertexExport == NULL)
{
pPhysiqueExport->ReleaseContextInterface(pContextExport);
pModifier->ReleaseInterface(I_PHYINTERFACE, pPhysiqueExport);
return;
}
// get the vertex type
int vertexType = pVertexExport->GetVertexType();
// handle the specific vertex type
if(vertexType == RIGID_TYPE)
{
// typecast to rigid vertex
IPhyRigidVertex *pTypeVertex = (IPhyRigidVertex *)pVertexExport;
Influence infl;
if( pTypeVertex->GetNode() )
{
strcpy( infl.szBoneName, pTypeVertex->GetNode()->GetName() );
infl.fWeight = 1.0f;
boneGroup.AddInfluence( infl );
}
else
return;
}
else if(vertexType == RIGID_BLENDED_TYPE)
{
// typecast to blended vertex
IPhyBlendedRigidVertex *pTypeVertex = (IPhyBlendedRigidVertex *)pVertexExport;
// loop through all influencing bones
Influence infl;
for(int nodeId = 0; nodeId < pTypeVertex->GetNumberNodes(); nodeId++)
{
strcpy( infl.szBoneName, pTypeVertex->GetNode( nodeId )->GetName() );
infl.fWeight = pTypeVertex->GetWeight( nodeId );
boneGroup.AddInfluence( infl );
}
}
// release all interfaces
pPhysiqueExport->ReleaseContextInterface(pContextExport);
pModifier->ReleaseInterface(I_PHYINTERFACE, pPhysiqueExport);
}
else if( nModifierType == MODIFIER_SKIN)
{
assert( pModifier && "get bone group error, modifier is null" );
// create a skin interface
ISkin *pSkin = (ISkin*)pModifier->GetInterface(I_SKIN);
if(pSkin == 0)
{
return;
}
// create a skin context data interface
ISkinContextData *pSkinContextData;
pSkinContextData = (ISkinContextData *)pSkin->GetContextInterface(pNode);
if(pSkinContextData == NULL)
{
pModifier->ReleaseInterface(I_SKIN, pSkin);
return;
}
// loop through all influencing bones
for(int nodeId = 0; nodeId < pSkinContextData->GetNumAssignedBones(nVertexId); nodeId++)
{
// get the bone id
int boneId = pSkinContextData->GetAssignedBone(nVertexId, nodeId);
if(boneId < 0)
continue;
INode* pBone = pSkin->GetBone( boneId );
Influence infl;
strcpy( infl.szBoneName, pBone->GetName() );
infl.fWeight = pSkinContextData->GetBoneWeight(nVertexId, nodeId);
boneGroup.AddInfluence( infl );
}
// release all interfaces
pModifier->ReleaseInterface(I_SKIN, pSkin);
}
}
CVertexCandidate *CMaxMesh::GetVertexCandidate(CSkeletonCandidate *pSkeletonCandidate, int faceId, int faceVertexId)
{
// check for valid mesh and physique modifier
if((m_pIMesh == 0))
{
theExporter.SetLastError("Invalid handle.", __FILE__, __LINE__);
return 0;
}
// check if face id is valid
if((faceId < 0) || (faceId >= m_pIMesh->getNumFaces()))
{
theExporter.SetLastError("Invalid face id found.", __FILE__, __LINE__);
return 0;
}
// check if face vertex id is valid
if((faceVertexId < 0) || (faceVertexId >= 3))
{
theExporter.SetLastError("Invalid face vertex id found.", __FILE__, __LINE__);
return 0;
}
// allocate a new vertex candidate
CVertexCandidate *pVertexCandidate;
pVertexCandidate = new CVertexCandidate();
if(pVertexCandidate == 0)
{
theExporter.SetLastError("Memory allocation failed.", __FILE__, __LINE__);
return 0;
}
// create the new vertex candidate
if(!pVertexCandidate->Create())
{
delete pVertexCandidate;
return 0;
}
// get vertex id
int vertexId;
vertexId = m_pIMesh->faces[faceId].v[faceVertexId];
// get the absolute vertex position
Point3 vertex;
vertex = m_pIMesh->getVert(vertexId) * m_tm;
// set the vertex candidate position
pVertexCandidate->SetPosition(vertex.x, vertex.y, vertex.z);
pVertexCandidate->SetUniqueId(vertexId);
// get the absolute vertex normal
Point3 normal;
normal = GetVertexNormal(faceId, vertexId);
normal = normal * Inverse(Transpose(m_tm));
normal = normal.Normalize();
// set the vertex candidate normal
pVertexCandidate->SetNormal(normal.x, normal.y, normal.z);
if(m_pIMesh->numCVerts > 0)
{
VertColor vc;
vc = m_pIMesh->vertCol[m_pIMesh->vcFace[faceId].t[faceVertexId]];
CalVector vcCal(vc.x, vc.y, vc.z);
pVertexCandidate->SetVertColor(vcCal);
}
// get the vertex weight array
float *pVertexWeights;
pVertexWeights = m_pIMesh->getVertexWeights();
//if( pVertexWeights == NULL ) {
// delete pVertexCandidate;
// theExporter.SetLastError("Mesh has no vertex weights", __FILE__, __LINE__);
// return 0;
//}
// get the vertex weight (if possible)
float weight;
if(pVertexWeights != 0)
{
weight = pVertexWeights[vertexId];
}
else
{
weight = 0.0f;
}
// another 3ds max weird behaviour:
// zero out epsilon weights
if(weight < 0.0005f) weight = 0.0f;
// set the vertex candidate weight
pVertexCandidate->SetPhysicalProperty(weight);
// get the material id of the face
int materialId;
materialId = GetFaceMaterialId(faceId);
if((materialId < 0) || (materialId >= (int)m_vectorStdMat.size()))
{
delete pVertexCandidate;
theExporter.SetLastError("Invalid material id found.", __FILE__, __LINE__);
return 0;
}
// get the material of the face
StdMat *pStdMat;
pStdMat = m_vectorStdMat[materialId];
// loop through all the mapping channels and extract texture coordinates
int mapId;
for(mapId = 0; mapId < pStdMat->NumSubTexmaps(); mapId++)
{
// get texture map
Texmap *pTexMap;
pTexMap = pStdMat->GetSubTexmap(mapId);
// check if map is valid
if((pTexMap != 0) && (pStdMat->MapEnabled(mapId)))
{
// get the mapping channel
int channel;
channel = pTexMap->GetMapChannel();
bool bValidUV;
bValidUV = false;
// extract the texture coordinate
UVVert uvVert;
if(m_pIMesh->mapSupport(channel))
{
TVFace *pTVFace;
pTVFace = m_pIMesh->mapFaces(channel);
UVVert *pUVVert;
pUVVert = m_pIMesh->mapVerts(channel);
uvVert = pUVVert[pTVFace[faceId].t[faceVertexId]];
bValidUV = true;
}
else if(m_pIMesh->numTVerts > 0)
{
uvVert = m_pIMesh->tVerts[m_pIMesh->tvFace[faceId].t[faceVertexId]];
bValidUV = true;
}
// if we found valid texture coordinates, add them to the vertex candidate
if(bValidUV)
{
// apply a possible uv generator
StdUVGen *pStdUVGen;
pStdUVGen = (StdUVGen *)pTexMap->GetTheUVGen();
if(pStdUVGen != 0)
{
Matrix3 tmUV;
pStdUVGen->GetUVTransform(tmUV);
uvVert = uvVert * tmUV;
}
// add texture coordinate to the vertex candidate, inverting the y coordinate
pVertexCandidate->AddTextureCoordinate(uvVert.x, 1.0f - uvVert.y);
}
}
}
// check for physique modifier
if(m_modifierType == MODIFIER_PHYSIQUE)
{
// create a physique export interface
IPhysiqueExport *pPhysiqueExport;
pPhysiqueExport = (IPhysiqueExport *)m_pModifier->GetInterface(I_PHYINTERFACE);
if(pPhysiqueExport == 0)
{
delete pVertexCandidate;
theExporter.SetLastError("Physique modifier interface not found.", __FILE__, __LINE__);
return 0;
}
// create a context export interface
IPhyContextExport *pContextExport;
pContextExport = (IPhyContextExport *)pPhysiqueExport->GetContextInterface(m_pINode);
if(pContextExport == 0)
{
m_pModifier->ReleaseInterface(I_PHYINTERFACE, pPhysiqueExport);
delete pVertexCandidate;
theExporter.SetLastError("Context export interface not found.", __FILE__, __LINE__);
return 0;
}
// set the flags in the context export interface
pContextExport->ConvertToRigid(TRUE);
pContextExport->AllowBlending(TRUE);
// get the vertex export interface
IPhyVertexExport *pVertexExport;
pVertexExport = (IPhyVertexExport *)pContextExport->GetVertexInterface(vertexId);
if(pVertexExport == 0)
{
pPhysiqueExport->ReleaseContextInterface(pContextExport);
m_pModifier->ReleaseInterface(I_PHYINTERFACE, pPhysiqueExport);
delete pVertexCandidate;
theExporter.SetLastError("Vertex export interface not found.", __FILE__, __LINE__);
return 0;
}
// get the vertex type
int vertexType;
vertexType = pVertexExport->GetVertexType();
// handle the specific vertex type
if(vertexType == RIGID_TYPE)
{
// typecast to rigid vertex
IPhyRigidVertex *pTypeVertex;
pTypeVertex = (IPhyRigidVertex *)pVertexExport;
// add the influence to the vertex candidate
// get the influencing bone
if(!AddBoneInfluence(pSkeletonCandidate, pVertexCandidate, pTypeVertex->GetNode(), 1.0f))
{
pPhysiqueExport->ReleaseContextInterface(pContextExport);
m_pModifier->ReleaseInterface(I_PHYINTERFACE, pPhysiqueExport);
delete pVertexCandidate;
theExporter.SetLastError("Invalid bone assignment.", __FILE__, __LINE__);
return 0;
}
}
else if(vertexType == RIGID_BLENDED_TYPE)
{
// typecast to blended vertex
IPhyBlendedRigidVertex *pTypeVertex;
pTypeVertex = (IPhyBlendedRigidVertex *)pVertexExport;
// loop through all influencing bones
int nodeId;
for(nodeId = 0; nodeId < pTypeVertex->GetNumberNodes(); nodeId++)
{
// add the influence to the vertex candidate
if(!AddBoneInfluence(pSkeletonCandidate, pVertexCandidate, pTypeVertex->GetNode(nodeId), pTypeVertex->GetWeight(nodeId)))
{
pPhysiqueExport->ReleaseContextInterface(pContextExport);
m_pModifier->ReleaseInterface(I_PHYINTERFACE, pPhysiqueExport);
delete pVertexCandidate;
theExporter.SetLastError("Invalid bone assignment.", __FILE__, __LINE__);
return 0;
}
}
}
// release all interfaces
pPhysiqueExport->ReleaseContextInterface(pContextExport);
m_pModifier->ReleaseInterface(I_PHYINTERFACE, pPhysiqueExport);
}
#if MAX_RELEASE >= 4000
// check for skin modifier
else if(m_modifierType == MODIFIER_SKIN)
{
// create a skin interface
ISkin *pSkin;
pSkin = (ISkin*)m_pModifier->GetInterface(I_SKIN);
if(pSkin == 0)
{
delete pVertexCandidate;
theExporter.SetLastError("Skin modifier interface not found.", __FILE__, __LINE__);
return 0;
}
// create a skin context data interface
ISkinContextData *pSkinContextData;
pSkinContextData = (ISkinContextData *)pSkin->GetContextInterface(m_pINode);
if(pSkinContextData == 0)
{
m_pModifier->ReleaseInterface(I_SKIN, pSkin);
delete pVertexCandidate;
theExporter.SetLastError("Skin context data interface not found.", __FILE__, __LINE__);
return 0;
}
// loop through all influencing bones
int nodeId;
for(nodeId = 0; nodeId < pSkinContextData->GetNumAssignedBones(vertexId); nodeId++)
{
// get the bone id
int boneId;
boneId = pSkinContextData->GetAssignedBone(vertexId, nodeId);
if(boneId < 0) continue;
// add the influence to the vertex candidate
if(!AddBoneInfluence(pSkeletonCandidate, pVertexCandidate, pSkin->GetBone(boneId), pSkinContextData->GetBoneWeight(vertexId, nodeId)))
{
m_pModifier->ReleaseInterface(I_SKIN, pSkin);
delete pVertexCandidate;
theExporter.SetLastError("Invalid bone assignment.", __FILE__, __LINE__);
return 0;
}
}
// release all interfaces
m_pModifier->ReleaseInterface(I_SKIN, pSkin);
}
#endif
else if( m_modifierType == MODIFIER_MORPHER || m_modifierType == MODIFIER_NONE ) {
}
else
{
theExporter.SetLastError("No physique/skin/morpher modifier found.", __FILE__, __LINE__);
return 0;
}
return pVertexCandidate;
}
//----------------------------------------------------------------------------
void SceneBuilder::ProcessSkin(INode *node, Modifier *skinMod)
{
// 构造皮肤控制器。如果Max的网格被按照材质细分，每一个网格都需要自己的蒙皮
// 信息控制器。蒙皮信息中的offset，在动画起始时被计算，是骨骼的世界变换。
//
// node:
// 指向蒙皮修改器指向的Max中的节点。
// skinMod:
// 指向蒙皮修改器
// 1. 获得max蒙皮信息中的骨骼，对应的在Phoenix的骨骼节点列表
// 2. 获得maxNode影响的Phoenix网格
// 3. 获得max中每个骨骼所影响的Phoenix网格中的顶点的数量，忽略不受蒙皮信息
// 影响的网格
// 4. 计算Phoenix mesh的蒙皮信息，生成SkinControl，AttachController到
// Phoenix mesh上。
// 1
bool needDel;
TriObject *triObj = GetTriObject(node, &needDel);
Mesh *maxMesh = &triObj->GetMesh();
// Max皮肤控制器接口
ISkin *skin = (ISkin*)skinMod->GetInterface(I_SKIN);
ISkinContextData *skinData = skin->GetContextInterface(node);
// max Skin Bones -> Phoenix2 Skin Bones
int b, numSkinBone = skin->GetNumBones();
PX2::Node **bones = new1<PX2::Node*>(numSkinBone);
for (b=0; b<numSkinBone; b++)
{
INode *boneNode = skin->GetBone(b);
const std::string &boneName = boneNode->GetName();
PX2::Node *node = PX2::StaticCast<PX2::Node>(mScene->GetObjectByName(boneName));
bones[b] = node;
}
// 1
// 获得maxNode相关联的Phoenix mesh
std::vector<PX2::TriMesh*> meshes;
PX2::Object *object = mScene->GetObjectByName(node->GetName());
if (object->IsExactly(PX2::TriMesh::TYPE))
{
meshes.push_back(PX2::StaticCast<PX2::TriMesh>(object));
}
else
{
PX2::Node *node = PX2::StaticCast<PX2::Node>(object);
const char *nName = node->GetName().c_str();
for (int c=0; c<node->GetNumChildren(); c++)
{
PX2::Movable *child = node->GetChild(c);
const char *cName = child->GetName().c_str();
if (strncmp(cName, nName, strlen(nName)) == 0) // 这里必须是strlen(nName),因为子节点有_1,_2
{
meshes.push_back(PX2::StaticCast<PX2::TriMesh>(child));
}
}
}
// 为Phoenix2的每个网格建立相关的皮肤控制器
int *boneInfuseNumVert = new1<int>(numSkinBone);
for (int m=0; m<(int)meshes.size(); m++)
{
PX2::TriMesh *mesh = meshes[m];
// Phoenix顶点在max顶点中的索引
PX2::VertexBuffer *vb = mesh->GetVertexBuffer();
int px2MeshVertexNum = vb->GetNumElements();
std::vector<int> MaxVertexIndex; // i->max索引
int v, i, j, k;
PX2::VertexBufferAccessor vba(mesh->GetVertexFormat(), vb);
// 3
for (int v=0; v<px2MeshVertexNum; ++v)
{
Float3 &position = vba.Position<Float3>(v);
for (i=0; i<maxMesh->getNumVerts(); i++)
{
if (position[0] == maxMesh->verts[i].x
&& position[1] == maxMesh->verts[i].y
&& position[2] == maxMesh->verts[i].z)
{
MaxVertexIndex.push_back(i);
break;
}
}
}
// 确定每个骨骼所影响的顶点数量
int maxVertexSize = (int)MaxVertexIndex.size();
memset(boneInfuseNumVert, 0, sizeof(int)*numSkinBone);
for (i=0; i<maxVertexSize; i++)
{
v = MaxVertexIndex[i];
for (j=0; j<skinData->GetNumAssignedBones(v); j++)
{ // 这个max中的顶点受到几个骨骼影响啊？！
b = skinData->GetAssignedBone(v, j); // 获得这个影响的骨骼索引(这个j是第几个)
boneInfuseNumVert[b]++; // 这个骨骼影响的顶点数量++
}
}
// (通过PX2中的顶点找到Max中的顶点，找到Max中影响该顶点的骨骼)
// 如果Max的网格是被按照材质分割的，可能一些骨骼对当前Phoenix2网格没有
// 影响
int bQuantity = 0; // 影响当前Phoenix2网格的骨骼数量
for (b=0; b<numSkinBone; b++)
{
if (boneInfuseNumVert[b] > 0)
bQuantity++;
}
if (bQuantity == 0)
{
// Phoenix网格不被任何骨骼影响，进入下一个网格
continue;
}
// 4
PX2::Node **theBones = new1<PX2::Node*>(bQuantity);
float **weight = new2<float>(bQuantity, maxVertexSize);
memset(weight[0],0,bQuantity*maxVertexSize*sizeof(float));
PX2::APoint **offset = new2<PX2::APoint>(bQuantity, maxVertexSize);
memset(offset[0],0,bQuantity*maxVertexSize*sizeof(PX2::APoint));
PX2::HMatrix *mats = new1<PX2::HMatrix>(bQuantity);
// 计算max骨骼到Phoenix骨骼对应的索引(k)
std::vector<int> bIArray(numSkinBone);
for (b=0, k=0; b<numSkinBone; b++)
{
if (boneInfuseNumVert[b] > 0)
{
theBones[k] = bones[b]; // 获取对Mesh有影响的骨骼
bIArray[b] = k; // max bone index -> px2 可用bone index
HMatrix boneWorldMat = theBones[k]->WorldTransform.Matrix();
HMatrix meshWorldMat = mesh->WorldTransform.Matrix();
mats[k] = boneWorldMat.Inverse() * meshWorldMat;
k++;
}
}
// 遍历顶点，计算顶点权重和offset
for (i=0; i<maxVertexSize; i++)
{
v = MaxVertexIndex[i];
for (j=0; j<skinData->GetNumAssignedBones(v); j++)
{ // 遍历影响该Max顶点的骨骼
b = skinData->GetAssignedBone(v, j);
k = bIArray[b];
float wit = skinData->GetBoneWeight(v, j); // 第j个骨骼的影响权重
weight[i][k] = wit;
Float3 &position = vba.Position<Float3>(i);
APoint point = theBones[k]->WorldTransform.Inverse()
* (mesh->WorldTransform * APoint(position));
offset[i][k] = Float3(point.X(), point.Y(), point.Z()); // 在所受影响骨骼中的位置
}
}
PX2::SkinController *skinCtrl = new0 PX2::SkinController
(maxVertexSize, bQuantity);
skinCtrl->SetName("SkinController");
for (int i=0; i<bQuantity; i++)
{
skinCtrl->GetBones()[i] = theBones[i];
skinCtrl->GetTMMatrixs()[i] = mats[i];
}
// offset
for (int i=0; i<maxVertexSize; i++)
{
for (int j=0; j<bQuantity; j++)
{
skinCtrl->GetWeights()[i][j] = weight[i][j];
skinCtrl->GetOffsets()[i][j] = offset[i][j];
}
}
// index weights
for (int i=0; i<maxVertexSize; i++)
{
Float4 inds = Float4(0.0f, 0.0f, 0.0f, 0.0f);
Float4 wights = Float4(0.0f, 0.0f, 0.0f, 0.0f);
In *pSortBone = new In[bQuantity];
for (int j=0; j<bQuantity; j++)
{
pSortBone[j].index = j;
pSortBone[j].data = weight[i][j];
}
qsort(pSortBone, bQuantity, sizeof(pSortBone[0]), cmp);
int useBoneNum = bQuantity;
if (useBoneNum > 4)
useBoneNum = 4;
float allWeight = 0.0f;
for (int useBoneIndex=0; useBoneIndex<useBoneNum; useBoneIndex++)
{
allWeight += pSortBone[useBoneIndex].data;
}
if (allWeight <= 0.0f)
allWeight = 1.0f;
for (int useBoneIndex=0; useBoneIndex<useBoneNum; useBoneIndex++)
{
inds[useBoneIndex] = (float)(pSortBone[useBoneIndex].index);
wights[useBoneIndex] = pSortBone[useBoneIndex].data/allWeight;
}
vba.TCoord<Float4>(1, i) = inds;
vba.TCoord<Float4>(2, i) = wights;
delete [] pSortBone;
}
skinCtrl->Repeat = Controller::RT_WRAP;
skinCtrl->MinTime = 0.0f;
skinCtrl->MaxTime = TicksToSec(mTimeEnd - mTimeStart);
mesh->AttachController(skinCtrl);
delete1(theBones);
delete2(weight);
delete2(offset);
delete1(mats);
}
if (needDel)
{
delete0(triObj);
}
delete1(bones);
delete1(boneInfuseNumVert);
}
