bool NifImporter::ImportCollision(NiNodeRef node)
{
bool ok = false;
if (!enableCollision)
return false;
// Currently only support the Oblivion bhk basic objects
bhkNiCollisionObjectRef collObj = node->GetCollisionObject();
if (collObj)
{
NiObjectRef body = collObj->GetBody();
if (body->IsDerivedType(bhkRigidBody::TYPE))
{
bhkRigidBodyRef rbody = DynamicCast<bhkRigidBody>(body);
if (bhkShapeRef shape = rbody->GetShape()) {
INode *node = NULL;
NiNodeRef target = collObj->GetTarget();
if (mergeNonAccum && target && wildmatch("* NonAccum", target->GetName()) ) {
node = FindNode(target->GetParent());
} else if (target && strmatch(target->GetName(), "Scene Root")) {
node = gi->GetRootNode();
} else {
node = FindNode(target);
}
CollisionImport ci(*this);
Matrix3 tm(true);
if (INode *body = ci.CreateRigidBody(rbody, node, tm))
{
if (!ci.ImportShape(body, rbody, shape, node, tm))
{
gi->DeleteNode(body, FALSE);
}
}
}
}
}
return ok;
}
bool NifImporter::ImportMultipleGeometry(NiNodeRef parent, vector<NiTriBasedGeomRef>& glist)
{
bool ok = true;
if (glist.empty()) return false;
ImpNode *node = i->CreateNode();
if(!node) return false;
INode *inode = node->GetINode();
TriObject *triObject = CreateNewTriObject();
node->Reference(triObject);
string name = parent->GetName();
node->SetName(wide(name).c_str());
// Texture
Mesh& mesh = triObject->GetMesh();
vector< pair<int, int> > vert_range, tri_range;
vector<Triangle> tris;
vector<Vector3> verts;
int submats = glist.size();
// Build list of vertices and triangles. Optional components like normals will be handled later.
for (vector<NiTriBasedGeomRef>::iterator itr = glist.begin(), end = glist.end(); itr != end; ++itr) {
NiTriBasedGeomDataRef triGeomData = StaticCast<NiTriBasedGeomData>((*itr)->GetData());
// Get verts and collapse local transform into them
int nVertices = triGeomData->GetVertexCount();
vector<Vector3> subverts = triGeomData->GetVertices();
Matrix44 transform = (*itr)->GetLocalTransform();
//Apply the transformations
if (transform != Matrix44::IDENTITY) {
for ( unsigned int i = 0; i < subverts.size(); ++i )
subverts[i] = transform * subverts[i];
}
vert_range.push_back( pair<int,int>( verts.size(), verts.size() + subverts.size()) );
verts.insert(verts.end(), subverts.begin(), subverts.end());
vector<Triangle> subtris = triGeomData->GetTriangles();
for (vector<Triangle>::iterator itr = subtris.begin(), end = subtris.end(); itr != end; ++itr) {
(*itr).v1 += nVertices, (*itr).v2 += nVertices, (*itr).v3 += nVertices;
}
tri_range.push_back( pair<int,int>( tris.size(), tris.size() + subtris.size()) );
tris.insert(tris.end(), subtris.begin(), subtris.end());
}
// Transform up-to-parent
Matrix44 baseTM = (importBones) ? Matrix44::IDENTITY : parent->GetWorldTransform();
node->SetTransform(0,TOMATRIX3(baseTM));
// Set vertices and triangles
mesh.setNumVerts(verts.size());
mesh.setNumTVerts(verts.size(), TRUE);
for (int i=0, n=verts.size(); i < n; ++i){
Vector3 &v = verts[i];
mesh.verts[i].Set(v.x, v.y, v.z);
}
mesh.setNumFaces(tris.size());
mesh.setNumTVFaces(tris.size());
for (int submat=0; submat<submats; ++submat) {
int t_start = tri_range[submat].first, t_end = tri_range[submat].second;
for (int i=t_start; i<t_end; ++i) {
Triangle& t = tris[i];
Face& f = mesh.faces[i];
f.setVerts(t.v1, t.v2, t.v3);
f.Show();
f.setEdgeVisFlags(EDGE_VIS, EDGE_VIS, EDGE_VIS);
f.setMatID(-1);
TVFace& tf = mesh.tvFace[i];
tf.setTVerts(t.v1, t.v2, t.v3);
}
}
mesh.buildNormals();
bool bSpecNorms = false;
MultiMtl *mtl = NULL;
int igeom = 0;
for (vector<NiTriBasedGeomRef>::iterator itr = glist.begin(), end = glist.end(); itr != end; ++itr, ++igeom)
{
NiTriBasedGeomDataRef triGeomData = StaticCast<NiTriBasedGeomData>((*itr)->GetData());
int v_start = vert_range[igeom].first, v_end = vert_range[igeom].second;
int t_start = tri_range[igeom].first, t_end = tri_range[igeom].second;
// Normals
vector<Vector3> subnorms = triGeomData->GetNormals();
Matrix44 rotation = (*itr)->GetLocalTransform().GetRotation();
if (rotation != Matrix44::IDENTITY) {
for ( unsigned int i = 0; i < subnorms.size(); ++i )
subnorms[i] = rotation * subnorms[i];
}
if (!subnorms.empty())
{
#if VERSION_3DSMAX > ((5000<<16)+(15<<8)+0) // Version 5
// Initialize normals if necessary
if (!bSpecNorms) {
bSpecNorms = true;
mesh.SpecifyNormals();
MeshNormalSpec *specNorms = mesh.GetSpecifiedNormals();
if (NULL != specNorms) {
specNorms->BuildNormals();
//specNorms->ClearAndFree();
//specNorms->SetNumFaces(tris.size());
//specNorms->SetNumNormals(n.size());
}
}
MeshNormalSpec *specNorms = mesh.GetSpecifiedNormals();
if (NULL != specNorms)
{
Point3* norms = specNorms->GetNormalArray();
for (int i=0, n=subnorms.size(); i<n; i++){
Vector3& v = subnorms[i];
norms[i+v_start] = Point3(v.x, v.y, v.z);
}
//MeshNormalFace* pFaces = specNorms->GetFaceArray();
//for (int i=0; i<tris.size(); i++){
// Triangle& tri = tris[i];
// MeshNormalFace& face = pFaces[i+t_start];
// face.SpecifyNormalID(0, tri.v1);
// face.SpecifyNormalID(1, tri.v2);
// face.SpecifyNormalID(2, tri.v3);
//}
#if VERSION_3DSMAX > ((7000<<16)+(15<<8)+0) // Version 7+
specNorms->SetAllExplicit(true);
#endif
specNorms->CheckNormals();
}
#endif
}
// uv texture info
if (triGeomData->GetUVSetCount() > 0) {
vector<TexCoord> texCoords = triGeomData->GetUVSet(0);
for (int i=0, n = texCoords.size(); i<n; ++i) {
TexCoord& texCoord = texCoords[i];
mesh.tVerts[i+v_start].Set(texCoord.u, (flipUVTextures) ? 1.0f-texCoord.v : texCoord.v, 0);
}
}
vector<Color4> cv = triGeomData->GetColors();
ImportVertexColor(inode, triObject, tris, cv, v_start);
if ( StdMat2* submtl = ImportMaterialAndTextures(node, (*itr)) )
{
if (mtl == NULL) {
mtl = NewDefaultMultiMtl();
gi->GetMaterialLibrary().Add(mtl);
inode->SetMtl(mtl);
}
// SubMatIDs do not have to be contiguous so we just use the offset
mtl->SetSubMtlAndName(igeom, submtl, submtl->GetName());
for (int i=t_start; i<t_end; ++i)
mesh.faces[i].setMatID(igeom);
}
if (enableSkinSupport)
ImportSkin(node, (*itr));
}
this->i->AddNodeToScene(node);
inode = node->GetINode();
inode->EvalWorldState(0);
for (vector<NiTriBasedGeomRef>::iterator itr = glist.begin(), end = glist.end(); itr != end; ++itr)
{
// attach child
if (INode *parent = GetNode((*itr)->GetParent()))
parent->AttachChild(inode, 1);
inode->Hide((*itr)->GetVisibility() ? FALSE : TRUE);
}
if (removeDegenerateFaces)
mesh.RemoveDegenerateFaces();
if (removeIllegalFaces)
mesh.RemoveIllegalFaces();
if (weldVertices)
WeldVertices(mesh);
if (enableAutoSmooth)
mesh.AutoSmooth(TORAD(autoSmoothAngle), FALSE, FALSE);
return ok;
}
/*---------------------------------------------------------------------------*/
unsigned int NifConvertUtility::convertShape(string fileNameSrc, string fileNameDst, string fileNameTmpl)
{
NiNodeRef pRootInput (NULL);
NiNodeRef pRootOutput (NULL);
NiNodeRef pRootTemplate (NULL);
NiTriShapeRef pNiTriShapeTmpl(NULL);
vector<NiAVObjectRef> srcChildList;
bool fakedRoot (false);
// test on existing file names
if (fileNameSrc.empty()) return NCU_ERROR_MISSING_FILE_NAME;
if (fileNameDst.empty()) return NCU_ERROR_MISSING_FILE_NAME;
if (fileNameTmpl.empty()) return NCU_ERROR_MISSING_FILE_NAME;
// initialize user messages
_userMessages.clear();
logMessage(NCU_MSG_TYPE_INFO, "Source: " + (fileNameSrc.empty() ? "- none -" : fileNameSrc));
logMessage(NCU_MSG_TYPE_INFO, "Template: " + (fileNameTmpl.empty() ? "- none -" : fileNameTmpl));
logMessage(NCU_MSG_TYPE_INFO, "Destination: " + (fileNameDst.empty() ? "- none -" : fileNameDst));
logMessage(NCU_MSG_TYPE_INFO, "Texture: " + (_pathTexture.empty() ? "- none -" : _pathTexture));
// initialize used texture list
_usedTextures.clear();
_newTextures.clear();
// read input NIF
if ((pRootInput = getRootNodeFromNifFile(fileNameSrc, "source", fakedRoot)) == NULL)
{
logMessage(NCU_MSG_TYPE_ERROR, "Can't open '" + fileNameSrc + "' as input");
return NCU_ERROR_CANT_OPEN_INPUT;
}
// get template nif
pRootTemplate = DynamicCast<BSFadeNode>(ReadNifTree((const char*) fileNameTmpl.c_str()));
if (pRootTemplate == NULL)
{
logMessage(NCU_MSG_TYPE_ERROR, "Can't open '" + fileNameTmpl + "' as template");
return NCU_ERROR_CANT_OPEN_TEMPLATE;
}
// get shapes from template
// - shape root
pNiTriShapeTmpl = DynamicCast<NiTriShape>(pRootTemplate->GetChildren().at(0));
if (pNiTriShapeTmpl == NULL)
{
logMessage(NCU_MSG_TYPE_INFO, "Template has no NiTriShape.");
}
// template root is used as root of output
pRootOutput = pRootTemplate;
// get rid of unwanted subnodes
pRootOutput->ClearChildren(); // remove all children
pRootOutput->SetCollisionObject(NULL); // unlink collision object
// hold extra data and property nodes
// copy translation from input node
pRootOutput->SetLocalTransform(pRootInput->GetLocalTransform());
// copy name of root node
pRootOutput->SetName(pRootInput->GetName());
// get list of children from input node
srcChildList = pRootInput->GetChildren();
// unlink children 'cause moved to output
pRootInput->ClearChildren();
// iterate over source nodes and convert using template
for (vector<NiAVObjectRef>::iterator ppIter = srcChildList.begin(); ppIter != srcChildList.end(); ppIter++)
{
// NiTriShape
if (DynamicCast<NiTriShape>(*ppIter) != NULL)
{
pRootOutput->AddChild(&(*convertNiTriShape(DynamicCast<NiTriShape>(*ppIter), pNiTriShapeTmpl)));
}
// RootCollisionNode
else if (DynamicCast<RootCollisionNode>(*ppIter) != NULL)
{
// ignore node
}
// NiNode (and derived classes?)
else if (DynamicCast<NiNode>(*ppIter) != NULL)
{
pRootOutput->AddChild(&(*convertNiNode(DynamicCast<NiNode>(*ppIter), pNiTriShapeTmpl, pRootOutput)));
}
}
// write missing textures to log - as block
for (set<string>::iterator pIter(_newTextures.begin()); pIter != _newTextures.end(); ++pIter)
{
logMessage(NCU_MSG_TYPE_TEXTURE_MISS, *pIter);
}
// write modified nif file
WriteNifTree((const char*) fileNameDst.c_str(), pRootOutput, NifInfo(VER_20_2_0_7, 12, 83));
return NCU_OK;
}
/*---------------------------------------------------------------------------*/
unsigned int NifConvertUtility::convertShape(string fileNameSrc, string fileNameDst, string fileNameTmpl)
{
cout << "Here3" << endl;
NiNodeRef pRootInput (NULL);
NiNodeRef pRootOutput (NULL);
NiNodeRef pRootTemplate (NULL);
NiTriShapeRef pNiTriShapeTmpl(NULL);
NiCollisionObjectRef pRootCollObject(NULL);
NifInfo nifInfo;
vector<NiAVObjectRef> srcChildList;
bool fakedRoot (false);
cout << "Here4" << endl;
// test on existing file names
if (fileNameSrc.empty()) return NCU_ERROR_MISSING_FILE_NAME;
if (fileNameDst.empty()) return NCU_ERROR_MISSING_FILE_NAME;
if (fileNameTmpl.empty()) return NCU_ERROR_MISSING_FILE_NAME;
cout << "Here5" << endl;
// initialize user messages
_userMessages.clear();
logMessage(NCU_MSG_TYPE_INFO, "Source: " + (fileNameSrc.empty() ? "- none -" : fileNameSrc));
logMessage(NCU_MSG_TYPE_INFO, "Template: " + (fileNameTmpl.empty() ? "- none -" : fileNameTmpl));
logMessage(NCU_MSG_TYPE_INFO, "Destination: " + (fileNameDst.empty() ? "- none -" : fileNameDst));
logMessage(NCU_MSG_TYPE_INFO, "Texture: " + (_pathTexture.empty() ? "- none -" : _pathTexture));
cout << "Here6" << endl;
// initialize used texture list
_usedTextures.clear();
_newTextures.clear();
cout << "Here7" << endl;
// read input NIF
if ((pRootInput = getRootNodeFromNifFile(fileNameSrc, "source", fakedRoot, &nifInfo)) == NULL)
{
logMessage(NCU_MSG_TYPE_ERROR, "Can't open '" + fileNameSrc + "' as input");
return NCU_ERROR_CANT_OPEN_INPUT;
}
cout << "Here8" << endl;
// get template nif
pRootTemplate = DynamicCast<BSFadeNode>(ReadNifTree((const char*) fileNameTmpl.c_str()));
if (pRootTemplate == NULL)
{
logMessage(NCU_MSG_TYPE_ERROR, "Can't open '" + fileNameTmpl + "' as template");
return NCU_ERROR_CANT_OPEN_TEMPLATE;
}
cout << "Here9" << endl;
// get shapes from template
// - shape root
pNiTriShapeTmpl = DynamicCast<NiTriShape>(pRootTemplate->GetChildren().at(0));
if (pNiTriShapeTmpl == NULL)
{
logMessage(NCU_MSG_TYPE_INFO, "Template has no NiTriShape.");
}
cout << "Here10" << endl;
// get data from input node
srcChildList = pRootInput->GetChildren();
pRootCollObject = pRootInput->GetCollisionObject();
cout << "Here11" << endl;
// template root is used as root of output
pRootOutput = pRootTemplate;
// move date from input to output
pRootInput ->SetCollisionObject(NULL);
pRootOutput->SetCollisionObject(pRootCollObject);
pRootOutput->SetLocalTransform(pRootInput->GetLocalTransform());
pRootOutput->SetName(pRootInput->GetName());
cout << "Here12" << endl;
// get rid of unwanted subnodes
pRootOutput->ClearChildren();
pRootInput->ClearChildren();
cout << "Here13" << endl;
// move children to output
for (auto pIter=srcChildList.begin(), pEnd=srcChildList.end(); pIter != pEnd; ++pIter)
{
pRootOutput->AddChild(*pIter);
}
cout << "Here14" << endl;
// iterate over source nodes and convert using template
root_bsafade = pRootOutput;
pRootOutput = convertNiNode(pRootOutput, pNiTriShapeTmpl, pRootOutput);
cout << "Here15" << endl;
// write missing textures to log - as block
for (auto pIter=_newTextures.begin(), pEnd=_newTextures.end(); pIter != pEnd; ++pIter)
{
logMessage(NCU_MSG_TYPE_TEXTURE_MISS, *pIter);
}
cout << "Here16" << endl;
// set version information
stringstream sStream;
cout << "Here17" << endl;
sStream << nifInfo.version << ';' << nifInfo.userVersion;
nifInfo.version = VER_20_2_0_7;
nifInfo.userVersion = 12;
nifInfo.userVersion2 = 83;
nifInfo.creator = "NifConvert";
nifInfo.exportInfo1 = MASTER_PRODUCT_VERSION_STR;
nifInfo.exportInfo2 = sStream.str();
cout << "Here18" << endl;
// write modified nif file
WriteNifTree((const char*) fileNameDst.c_str(), pRootOutput, nifInfo);
cout << "Here19" << endl;
return NCU_OK;
}
NiNodeRef NifConvertUtility::convertNiNode(NiNodeRef pSrcNode, NiTriShapeRef pTmplNode, NiNodeRef pRootNode, NiAlphaPropertyRef pTmplAlphaProp)
{
NiNodeRef pDstNode (pSrcNode);
//pDstNode->SetName(pDstNode->GetName().replace(
string node_name_in = pDstNode->GetName();
string node_name_out = "";
for (int i = 0; i < node_name_in.length(); i++)
{
if (node_name_in[i] != '.' && node_name_in[i] != '_' && node_name_in[i] != ' ')
{
node_name_out = node_name_out + node_name_in[i];
}
}
pDstNode->SetName(node_name_out);
node_name_in = node_name_out;
if (node_name_in.compare("AttachLight") == 0)
{
Vector3 tr = pDstNode->GetLocalTranslation();
tr.z += 10.0f;
pDstNode->SetLocalTranslation(tr);
}
if (node_name_in.compare("ShadowBox") == 0)
{
cout << "Removing ShadowBox" << endl;
pDstNode->ClearChildren();
}
if (toLower(node_name_in).find("fireemit") != -1)
{
NiExtraDataRef ed = root_bsafade->GetExtraData().front();
NiIntegerExtraDataRef iref = DynamicCast<NiIntegerExtraData>(ed);
iref->SetData(147);
cout << "Adding TorchFlame Addon" << endl;
BSValueNodeRef candle_flame = new BSValueNode();
candle_flame->SetName("AddOnNode");
candle_flame->value = 46;
pDstNode->AddChild(DynamicCast<NiAVObject>(candle_flame));
}
else if (node_name_in.find("CandleFlame") != -1)
{
NiExtraDataRef ed = root_bsafade->GetExtraData().front();
NiIntegerExtraDataRef iref = DynamicCast<NiIntegerExtraData>(ed);
iref->SetData(147);
cout << "Adding CandleFlame Addon" << endl;
BSValueNodeRef candle_flame = new BSValueNode();
candle_flame->SetName("AddOnNode");
candle_flame->value = 49;
pDstNode->AddChild(DynamicCast<NiAVObject>(candle_flame));
}
vector<NiAVObjectRef> srcShapeList(pDstNode->GetChildren());
//if (!pDstNode->GetType().IsSameType(NiNode::TYPE) && !pDstNode->GetType().IsSameType(BSFadeNode::TYPE) && !pDstNode->GetType().IsSameType(NiTriShape::TYPE) && !pDstNode->GetType().IsSameType(NiTriStrips::TYPE))
{
}
// find NiAlphaProperty and use as template in sub-nodes
if (DynamicCast<NiAlphaProperty>(pDstNode->GetPropertyByType(NiAlphaProperty::TYPE)) != NULL)
{
pTmplAlphaProp = DynamicCast<NiAlphaProperty>(pDstNode->GetPropertyByType(NiAlphaProperty::TYPE));
}
// unlink protperties -> not used in new format
pDstNode->ClearProperties();
// shift extra data to new version
pDstNode->ShiftExtraData(VER_20_2_0_7);
// unlink children
pDstNode->ClearChildren();
pDstNode->ClearEffects();
pDstNode->ClearControllers();
if (!pDstNode->GetType().IsSameType(BSFadeNode::TYPE))
{
pDstNode->ClearExtraData();
}
// iterate over source nodes and convert using template
for (auto ppIter=srcShapeList.begin(), pEnd=srcShapeList.end(); ppIter != pEnd; ppIter++)
{
//DynamicCast<NiTriShape>(*ppIter) == NULL && DynamicCast<NiTriStrips>(*ppIter) == NULL ** DynamicCast<NiTriStrips>(*ppIter) != NULL
// NiTriShape
if (DynamicCast<NiTriShape>(*ppIter) != NULL)
{
pDstNode->AddChild(&(*convertNiTriShape(DynamicCast<NiTriShape>(*ppIter), pTmplNode, pTmplAlphaProp)));
}
// NiTriStrips
else if (DynamicCast<NiTriStrips>(*ppIter) != NULL)
{
pDstNode->AddChild(&(*convertNiTriStrips(DynamicCast<NiTriStrips>(*ppIter), pTmplNode, pTmplAlphaProp)));
}
// RootCollisionNode
else if ((DynamicCast<RootCollisionNode>(*ppIter) != NULL) && _cleanTreeCollision)
{
// ignore node
}
// NiNode (and derived classes?)
else if (DynamicCast<NiNode>(*ppIter) != NULL)
{
NiNode* node_hashmi = DynamicCast<NiNode>(*ppIter);
if (node_hashmi->GetType().IsSameType(NiNode::TYPE) || node_hashmi->GetType().IsSameType(BSFadeNode::TYPE) || node_hashmi->GetType().IsSameType(BSValueNode::TYPE))
{
pDstNode->AddChild(&(*convertNiNode(DynamicCast<NiNode>(*ppIter), pTmplNode, pRootNode, pTmplAlphaProp)));
}
}
}
// remove collision object (newer version)
if (_cleanTreeCollision)
{
pDstNode->SetCollisionObject(NULL);
}
else if (DynamicCast<bhkCollisionObject>(pDstNode->GetCollisionObject()) != NULL)
{
bhkRigidBodyRef pBody(DynamicCast<bhkRigidBody>((DynamicCast<bhkCollisionObject>(pDstNode->GetCollisionObject()))->GetBody()));
if (pBody != NULL)
{
parseCollisionTree(pBody->GetShape());
}
}
return pDstNode;
}
void NifImporter::ImportBones(NiNodeRef node, bool recurse)
{
try
{
if (uncontrolledDummies)
BuildControllerRefList(node, ctrlCount);
string name = node->GetName();
vector<NiAVObjectRef> children = node->GetChildren();
vector<NiNodeRef> childNodes = DynamicCast<NiNode>(children);
NiAVObject::CollisionType cType = node->GetCollisionMode();
if (children.empty() && name == "Bounding Box")
return;
// Do all node manipulations here
NiNodeRef parent = node->GetParent();
string parentname = (parent ? parent->GetName() : "");
Matrix44 m4 = node->GetWorldTransform();
// Check for Prn strings and change parent if necessary
if (supportPrnStrings) {
list<NiStringExtraDataRef> strings = DynamicCast<NiStringExtraData>(node->GetExtraData());
for (list<NiStringExtraDataRef>::iterator itr = strings.begin(); itr != strings.end(); ++itr){
if (strmatch((*itr)->GetName(), "Prn")) {
parentname = (*itr)->GetData();
if (INode *pn = gi->GetINodeByName(parentname.c_str())){
// Apparently Heads tend to need to be rotated 90 degrees on import for
if (!rotate90Degrees.empty() && wildmatch(rotate90Degrees, parentname)) {
m4 *= TOMATRIX4(RotateYMatrix(TORAD(90)));
}
m4 *= TOMATRIX4(pn->GetObjTMAfterWSM(0, NULL));
}
}
}
}
float len = node->GetLocalTranslation().Magnitude();
// Remove NonAccum nodes and merge into primary bone
if (mergeNonAccum && wildmatch("* NonAccum", name) && parent)
{
string realname = name.substr(0, name.length() - 9);
if (strmatch(realname, parent->GetName()))
{
Matrix44 tm = parent->GetLocalTransform() * node->GetLocalTransform();
name = realname;
len += tm.GetTranslation().Magnitude();
parent = parent->GetParent();
}
}
PosRotScale prs = prsDefault;
Vector3 pos; Matrix33 rot; float scale;
m4.Decompose(pos, rot, scale);
Matrix3 im = TOMATRIX3(m4);
Point3 p = im.GetTrans();
Quat q(im);
//q.Normalize();
Vector3 ppos;
Point3 zAxis(0,0,0);
bool hasChildren = !children.empty();
if (hasChildren) {
float len = 0.0f;
for (vector<NiAVObjectRef>::iterator itr=children.begin(), end = children.end(); itr != end; ++itr) {
len += GetObjectLength(*itr);
}
len /= float(children.size());
ppos = pos + Vector3(len, 0.0f, 0.0f); // just really need magnitude as rotation will take care of positioning
}
else if (parent)
{
ppos = pos + Vector3(len/3.0f, 0.0f, 0.0f);
}
Point3 pp(ppos.x, ppos.y, ppos.z);
Point3 qp = TORAD(TOEULER(im));
INode *bone = NULL;
if (!doNotReuseExistingBones) // Games like BC3 reuse the same bone names
{
bone = FindNode(node);
if (bone == NULL)
bone = gi->GetINodeByName(name.c_str());
}
if (bone)
{
// Is there a better way of "Affect Pivot Only" behaviors?
INode *pinode = bone->GetParentNode();
if (pinode)
bone->Detach(0,1);
PosRotScaleNode(bone, p, q, scale, prs);
if (pinode)
pinode->AttachChild(bone, 1);
}
else
{
bool isDummy = ( (uncontrolledDummies && !HasControllerRef(ctrlCount, name))
|| (!dummyNodeMatches.empty() && wildmatch(dummyNodeMatches, name))
|| (convertBillboardsToDummyNodes && node->IsDerivedType(NiBillboardNode::TYPE))
);
if (wildmatch("Camera*", name)) {
if (enableCameras) {
if (bone = CreateCamera(name)) {
PosRotScaleNode(bone, p, q, scale, prs);
bone->Hide(node->GetVisibility() ? FALSE : TRUE);
}
}
}else if (isDummy && createNubsForBones)
bone = CreateHelper(name, p);
else if (bone = CreateBone(name, p, pp, zAxis))
{
PosRotScaleNode(bone, p, q, scale, prs);
bone->Hide(node->GetVisibility() ? FALSE : TRUE);
}
if (bone)
{
if (!parentname.empty())
{
if (mergeNonAccum && wildmatch("* NonAccum", parentname)) {
parentname = parentname.substr(0, parentname.length() - 9);
}
if (INode *pn = gi->GetINodeByName(parentname.c_str()))
pn->AttachChild(bone, 1);
}
RegisterNode(node, bone);
}
}
// Import UPB
if (bone) ImportUPB(bone, node);
// Import Havok Collision Data surrounding node,
// unfortunately this causes double import of collision so I'm disabling it for now.
if (enableCollision && node->GetParent()) {
ImportCollision(node);
}
if (bone && recurse)
{
ImportBones(childNodes);
}
}
catch( exception & e )
{
e=e;
}
catch( ... )
{
}
}
void NifImporter::AlignBiped(IBipMaster* master, NiNodeRef node)
{
#ifdef USE_BIPED
NiNodeRef parent = node->GetParent();
string name = node->GetName();
vector<NiAVObjectRef> children = node->GetChildren();
vector<NiNodeRef> childNodes = DynamicCast<NiNode>(children);
TSTR s1 = FormatText("Processing %s:", name.c_str());
TSTR s2 = FormatText("Processing %s:", name.c_str());
INode *bone = GetNode(node);
if (bone != NULL)
{
if (uncontrolledDummies)
BuildControllerRefList(node, ctrlCount);
Matrix44 m4 = node->GetWorldTransform();
Vector3 pos; Matrix33 rot; float scale;
m4.Decompose(pos, rot, scale);
Matrix3 m = TOMATRIX3(m4);
Point3 p = m.GetTrans();
Quat q(m);
s1 += FormatText(" ( %s)", PrintMatrix3(m).data());
if (strmatch(name, master->GetRootName()))
{
// Align COM
//PosRotScaleNode(bone, p, q, 1.0f, prsPos);
PosRotScaleBiped(master, bone, p, q, 1.0f, prsPos);
}
else if (INode *pnode = bone->GetParentNode())
{
// Reparent if necessary
if (!strmatch(parent->GetName(), pnode->GetName())) {
if (pnode = FindNode(parent)) {
bone->Detach(0);
pnode->AttachChild(bone);
}
}
// Hack to scale the object until it fits
for (int i=0; i<10; ++i) {
float s = CalcScale(bone, node, childNodes);
if (fabs(s-1.0f) < (FLT_EPSILON*100.0f))
break;
s1 += FormatText(" (%g)", s);
master->SetBipedScale(TRUE, ScaleValue(Point3(s,s,s)), 0, bone);
}
PosRotScale prs = prsDefault;
PosRotScaleBiped(master, bone, p, q, scale, prs);
// Rotation with Clavicle is useless in Figure Mode using the standard interface
// I was tring unsuccessfully to correct for it
//if (wildcmpi("Bip?? ? Clavicle", name.c_str())) {
// AngAxis a1 = CalcTransform(bone, node, childNodes);
// Matrix3 tm1 = GenerateRotMatrix(a1);
// Quat nq = TransformQuat(tm1, q);
// PosRotScaleNode(bone, p, nq, scale, prsRot);
//}
}
s2 += FormatText(" ( %s)", PrintMatrix3(bone->GetNodeTM(0)).data());
}
else
{
ImportBones(node, false);
}
for (char *p = s1; *p != 0; ++p) if (isspace(*p)) *p = ' ';
for (char *p = s2; *p != 0; ++p) if (isspace(*p)) *p = ' ';
OutputDebugString(s1 + "\n");
OutputDebugString(s2 + "\n");
for (vector<NiNodeRef>::iterator itr = childNodes.begin(), end = childNodes.end(); itr != end; ++itr){
AlignBiped(master, *itr);
}
#endif
}
bool operator()(const NiNodeRef& n1, const NiNodeRef& n2) const {
return NumericStringEquivalence::operator()(n1->GetName(), n2->GetName());
}
bool NifImporter::DoImport()
{
bool ok = true;
if (!suppressPrompts)
{
if (!ShowDialog())
return true;
ApplyAppSettings();
SaveIniSettings();
}
vector<string> importedBones;
if (!isBiped && importSkeleton && importBones)
{
if (importSkeleton && !skeleton.empty()) {
try
{
NifImporter skelImport(skeleton.c_str(), i, gi, suppressPrompts);
if (skelImport.isValid())
{
// Enable Skeleton specific items
skelImport.isBiped = true;
skelImport.importBones = true;
// Disable undesirable skeleton items
skelImport.enableCollision = false;
skelImport.enableAnimations = false;
skelImport.suppressPrompts = true;
skelImport.DoImport();
if (!skelImport.useBiped && removeUnusedImportedBones)
importedBones = GetNamesOfNodes(skelImport.nodes);
}
}
catch (RuntimeError &error)
{
// ignore import errors and continue
}
}
} else if (hasSkeleton && useBiped && importBones) {
ImportBipeds(nodes);
}
if (isValid()) {
if (root->IsDerivedType(NiNode::TYPE))
{
NiNodeRef rootNode = root;
if (importBones) {
if (ignoreRootNode || strmatch(rootNode->GetName(), "Scene Root")) {
RegisterNode(root, gi->GetRootNode());
ImportBones(DynamicCast<NiNode>(rootNode->GetChildren()));
} else {
ImportBones(rootNode);
}
}
if (enableLights){
ok = ImportLights(rootNode);
}
ok = ImportMeshes(rootNode);
// Import Havok Collision Data surrounding node
if (enableCollision) {
ImportCollision(rootNode);
}
if (importSkeleton && removeUnusedImportedBones){
vector<string> importedNodes = GetNamesOfNodes(nodes);
sort(importedBones.begin(), importedBones.end());
sort(importedNodes.begin(), importedNodes.end());
vector<string> results;
results.resize(importedBones.size());
vector<string>::iterator end = set_difference (
importedBones.begin(), importedBones.end(),
importedNodes.begin(), importedNodes.end(), results.begin());
for (vector<string>::iterator itr = results.begin(); itr != end; ++itr){
if (INode *node = gi->GetINodeByName((*itr).c_str())){
gi->DeleteNode(node, FALSE);
}
}
}
}
else if (root->IsDerivedType(NiTriShape::TYPE))
{
ok |= ImportMesh(NiTriShapeRef(root));
}
else if (root->IsDerivedType(NiTriStrips::TYPE))
{
ok |= ImportMesh(NiTriStripsRef(root));
}
}
ClearAnimation();
ImportAnimation();
return true;
}
