//------------------------------
bool NodeImporter::importNodes ( const COLLADAFW::NodePointerArray& nodes )
{
for ( size_t i = 0, count = nodes.getCount(); i < count; ++i)
{
if ( !importNode( nodes[i] ) )
return false;
}
return true;
}
//------------------------------
bool SceneGraphCreator::importNodes( const COLLADAFW::NodePointerArray& nodeArray, INode* parentINode )
{
for ( size_t i = 0, count = nodeArray.getCount(); i < count; ++i)
{
ImpNode* newNode = importNode(nodeArray[i], parentINode);
}
return true;
}
void ConstCacheFriendlyTree<ValueType>::importNode( const typename BasicTree<ValueType>::Node* node ) {
if ( node ) {
const size_t iThisNode = nodes_.size();
nodes_.push_back( Node( node->value() ) );
if ( node->getLeft() ) {
nodes_[iThisNode].traversal.hasLeftNode_ = true;
nodes_[iThisNode].traversal.isLeaf = false;
importNode( node->getLeft() );
}
if ( node->getRight() ) {
nodes_[iThisNode].traversal.rightNodeOffset = nodes_.size() - iThisNode;
nodes_[iThisNode].traversal.isLeaf = false;
importNode( node->getRight() );
}
}
}
//------------------------------
bool NodeImporter::importNode ( const COLLADAFW::Node* node )
{
const COLLADAFW::UniqueId& nodeId = node->getUniqueId();
addUniqueIdFWNode ( nodeId, node );
const COLLADAFW::NodePointerArray& childNodes = node->getChildNodes();
for ( size_t i = 0, count = childNodes.getCount(); i < count; ++i)
{
if ( !importNode( childNodes[i] ) )
{
return false;
}
}
return true;
}
Node *
importNode(Node * parent, ireader & reader)
{
const std::string nodeName = reader.getString();
auto it = _nodeReader.find(nodeName);
if (it == _nodeReader.end())
throw new WUPException("Unknown node type");
Node * newNode = it->second(parent, reader);
const int numChildren = reader.get();
//LOGE("Importing node of type %s with %d children, loading", nodeName.c_str(), numChildren);
for (int i=0;i<numChildren;++i)
newNode->addChild(importNode(newNode, reader));
return newNode;
}
StreamEncoder(ireader & reader) :
_root(nullptr),
_last(nullptr)
{
registerNodeReaders();
if (reader.get() != -1)
throw new WUPException("Invalid file");
if (reader.get() == 1)
{
//LOGE("Has root, loading");
_root = importNode(nullptr, reader);
_last = _root->lastDescendant();
}
if (reader.get() != -1)
throw new WUPException("Invalid file");
}
void NewstuffModelPrivate::updateModel()
{
QDomNodeList items = m_root.elementsByTagName( "stuff" );
#if QT_VERSION < 0x050000
unsigned int i=0;
#else
int i=0;
#endif
for ( ; i < items.length(); ++i ) {
QString const key = m_idTag == NewstuffModel::PayloadTag ? "payload" : "name";
QDomNodeList matches = items.item( i ).toElement().elementsByTagName( key );
if ( matches.size() == 1 ) {
QString const value = matches.at( 0 ).toElement().text();
bool found = false;
for ( int j=0; j<m_items.size() && !found; ++j ) {
NewstuffItem &item = m_items[j];
if ( m_idTag == NewstuffModel::PayloadTag && item.m_payloadUrl == value ) {
item.m_registryNode = items.item( i );
found = true;
}
if ( m_idTag == NewstuffModel::NameTag && item.m_name == value ) {
item.m_registryNode = items.item( i );
found = true;
}
}
if ( !found ) {
// Not found in newstuff or newstuff not there yet
NewstuffItem item = importNode( items.item( i ) );
if ( m_idTag == NewstuffModel::PayloadTag ) {
item.m_registryNode = items.item( i );
} else if ( m_idTag == NewstuffModel::NameTag ) {
item.m_registryNode = items.item( i );
}
m_items << item;
}
}
}
m_parent->beginResetModel();
m_parent->endResetModel();
}
//------------------------------
bool SceneGraphCreator::importInstanceNodes( const COLLADAFW::InstanceNodePointerArray& instanceNodeArray, ImpNode* parentImportNode )
{
for ( size_t i = 0, count = instanceNodeArray.getCount(); i < count; ++i)
{
COLLADAFW::InstanceNode* instanceNode = instanceNodeArray[i];
const COLLADAFW::UniqueId& uniqueId = instanceNode->getInstanciatedObjectId();
INode* instanciatedINode = getINodeByUniqueId(uniqueId);
// check if the referenced node is already in the max scene graph
if ( instanciatedINode )
{
if ( !recursivelyCloneINode(parentImportNode, instanciatedINode) )
return false;;
}
else
{
const COLLADAFW::Node* instanciatedFWNode = getFWNodeByUniqueId( uniqueId );
// check if the referenced node is in one of the already received library nodes
if ( instanciatedFWNode )
{
importNode( instanciatedFWNode, parentImportNode->GetINode() );
}
#if 0
else
{
// If the referenced node has not been imported, store which node is referenced
// to clone the nodes as the referenced nodes gets imported
addUniqueIdReferencingImpNodePair(instanceNode->getInstanciatedObjectId(), parentImportNode );
}
#endif
}
}
return true;
}
reNode* reFBXAsset::importNode(FbxNode* fbxNode, reNode* parent)
{
reNode* node = new reNode;
node->name(fbxNode->GetName());
FbxMatrix mat = fbxNode->EvaluateGlobalTransform(FbxTime(0));
FbxNode *fbxParent = fbxNode->GetParent();
if (!fbxParent)
{
node->transform (reTransform(fromFBXMatrix(mat)));
}
else
{
FbxMatrix pmat = fbxParent->EvaluateGlobalTransform(FbxTime(0));
node->transform(reTransform(fromFBXMatrix(pmat.Inverse()) * fromFBXMatrix(mat)));
}
if (fbxNode->GetNodeAttribute() )
{
FbxNodeAttribute::EType attrType = (fbxNode->GetNodeAttribute()->GetAttributeType());
switch (attrType)
{
case FbxNodeAttribute::eMesh:
reMesh* mesh = importMesh(fbxNode);
node->renderables->add(mesh);
break;
}
}
for(int i = 0; i < fbxNode->GetChildCount(); i++)
{
reNode* child = importNode(fbxNode->GetChild(i), node);
node->children->add(child);
}
return node;
};
void reFBXAsset::import()
{
FbxImporter* importer = FbxImporter::Create(sdk,"");
meshes = new reFileAsset(this);
meshes->setPath("meshes");
children.push_back(meshes);
if(!importer->Initialize(path().toUtf8().constData(), -1, sdk->GetIOSettings())) {
printf("Call to FbxImporter::Initialize() failed.\n");
printf("Error returned: %s\n\n", importer->GetLastErrorString());
return;
}
FbxScene* lScene = FbxScene::Create(sdk, "myScene");
FbxAxisSystem ga(FbxAxisSystem::OpenGL);
ga.ConvertScene(lScene);
importer->Import(lScene);
FbxNode* lRootNode = lScene->GetRootNode();
if(lRootNode) {
reNode* node = importNode(lRootNode, NULL);
node->name(info.baseName().toStdString());
QString path = dataDir() + QDir::separator() + node->name().c_str() + ".json";
node->save(path.toStdString());
}
importer->Destroy();
}
void NewstuffModelPrivate::handleProviderData(QNetworkReply *reply)
{
if ( reply->operation() == QNetworkAccessManager::HeadOperation ) {
const QVariant redirectionAttribute = reply->attribute( QNetworkRequest::RedirectionTargetAttribute );
if ( !redirectionAttribute.isNull() ) {
for ( int i=0; i<m_items.size(); ++i ) {
NewstuffItem &item = m_items[i];
if ( item.m_payloadUrl == reply->url() ) {
item.m_payloadUrl = redirectionAttribute.toUrl();
}
}
m_networkAccessManager.head( QNetworkRequest( redirectionAttribute.toUrl() ) );
return;
}
QVariant const size = reply->header( QNetworkRequest::ContentLengthHeader );
if ( size.isValid() ) {
qint64 length = size.value<qint64>();
for ( int i=0; i<m_items.size(); ++i ) {
NewstuffItem &item = m_items[i];
if ( item.m_payloadUrl == reply->url() ) {
item.m_payloadSize = length;
QModelIndex const affected = m_parent->index( i );
emit m_parent->dataChanged( affected, affected );
}
}
}
return;
}
FetchPreviewJob *const job = m_networkJobs.take( reply );
// check if we are redirected
const QVariant redirectionAttribute = reply->attribute( QNetworkRequest::RedirectionTargetAttribute );
if ( !redirectionAttribute.isNull() ) {
QNetworkReply *redirectReply = m_networkAccessManager.get( QNetworkRequest( QUrl( redirectionAttribute.toUrl() ) ) );
if ( job ) {
m_networkJobs.insert( redirectReply, job );
}
return;
}
if ( job ) {
job->run( reply->readAll() );
delete job;
return;
}
QDomDocument xml;
if ( !xml.setContent( reply->readAll() ) ) {
mDebug() << "Cannot parse newstuff xml data ";
return;
}
m_items.clear();
QDomElement root = xml.documentElement();
QDomNodeList items = root.elementsByTagName( "stuff" );
#if QT_VERSION < 0x050000
unsigned int i=0;
#else
int i=0;
#endif
for ( ; i < items.length(); ++i ) {
m_items << importNode( items.item( i ) );
}
updateModel();
}
void ConstCacheFriendlyTree<ValueType>::buildFromSimpleBinaryTree( const BasicTree<ValueType>& bt ) {
nodes_.clear();
nodes_.reserve( bt.size() );
importNode( bt.root() );
}
