BVHAccelTreeNode *BVHAccel::BuildHierarchy(std::vector<BVHAccelTreeNode *> &list, unsigned int begin, unsigned int end, unsigned int axis) { unsigned int splitAxis = axis; float splitValue; nNodes += 1; if (end - begin == 1) // Only a single item in list so return it return list[begin]; BVHAccelTreeNode *parent = new BVHAccelTreeNode(); parent->primitive = 0xffffffffu; parent->leftChild = NULL; parent->rightSibling = NULL; std::vector<unsigned int> splits; splits.reserve(treeType + 1); splits.push_back(begin); splits.push_back(end); for (unsigned int i = 2; i <= treeType; i *= 2) { // Calculate splits, according to tree type and do partition for (unsigned int j = 0, offset = 0; j + offset < i && splits.size() > j + 1; j += 2) { if (splits[j + 1] - splits[j] < 2) { j--; offset++; continue; // Less than two elements: no need to split } FindBestSplit(list, splits[j], splits[j + 1], &splitValue, &splitAxis); std::vector<BVHAccelTreeNode *>::iterator it = partition(list.begin() + splits[j], list.begin() + splits[j + 1], bind2nd(ptr_fun(bvh_ltf[splitAxis]), splitValue)); unsigned int middle = distance(list.begin(), it); middle = Max(splits[j] + 1, Min(splits[j + 1] - 1, middle)); // Make sure coincidental BBs are still split splits.insert(splits.begin() + j + 1, middle); } } BVHAccelTreeNode *child, *lastChild; // Left Child child = BuildHierarchy(list, splits[0], splits[1], splitAxis); parent->leftChild = child; parent->bbox = child->bbox; lastChild = child; // Add remaining children for (unsigned int i = 1; i < splits.size() - 1; i++) { child = BuildHierarchy(list, splits[i], splits[i + 1], splitAxis); lastChild->rightSibling = child; parent->bbox = Union(parent->bbox, child->bbox); lastChild = child; } return parent; }
bool ColladaMeshFactory::LoadModelWithFilePath( RevModel** aModel, const char* aFilePath ) { FCDocument* colladDoc; colladDoc=FCollada::NewTopDocument(); bool sucess=FCollada::LoadDocumentFromFile(colladDoc, aFilePath ); if(sucess==false) return(false); if(colladDoc==NULL) return(false); FCDGeometryLibrary* geometryLibrary=colladDoc->GetGeometryLibrary(); unsigned int numberOfMeshes=0; for (unsigned int i=0; i< geometryLibrary->GetEntityCount(); i++) { if (geometryLibrary->GetEntity(i)->IsMesh()==true) { numberOfMeshes++; } } BuildHierarchy(colladDoc,aModel, colladDoc->GetVisualSceneInstance()); CU::Matrix44f mayaAdapter,temp; mayaAdapter.myMatrix[0][0]=-1; (*aModel)->SetBaseModelMatrix( mayaAdapter ); //aModelNode->myTransformationNode->SetOrientation(temp); return(true); }
// Recursively builds hierarchy of items inside the archive void CArchive::BuildHierarchy(const std::string &fldPath, std::vector<IResource*> &children) { for(size_t i = 0; i != mItems.size(); ++i) { const std::string& fullpath = mItems[i]->FullPath(); if(fullpath.size() <= fldPath.size()) continue; std::pair<int, int> p = GetSubpathBouds(fldPath, fullpath); if(p.second < p.first) continue; bool top = true; for(int j = p.first; j != p.second; ++j) if(fullpath[j] == '/') top = false; if(top) { // Adding top-level child mItems[i]->AddRef(); children.push_back(mItems[i]); // If it is folder - recursion if(Module::com_ptr<IFolder> f = mItems[i]) BuildHierarchy(fullpath, static_cast<CArchFolder*>(mItems[i])->mChildren); } } }
const std::vector<IResource*>& CArchive::GetChildren() { if(!mChildren.size()) { InitItems(); BuildHierarchy(mPath.string(), mChildren); } return mChildren; }
/* * Function Name: main * Description: * Arguments: the usual suspects * Returns: nothing * */ int main(int argc, char **argv) { Widget top, pane; Arg args[10]; Cardinal num_args; XtAppContext app_con; num_args = 0; XtSetArg(args[num_args], XmNtitle, "Outline Demo"); num_args++; XtSetArg(args[num_args], XmNallowShellResize, True); num_args++; top = XtAppInitialize(&app_con, "Treedemo", NULL, 0, &argc, argv, fallbacks, args, num_args); { Widget sw; num_args = 0; pane = XtCreateManagedWidget("pane", xmPanedWindowWidgetClass, top, args, num_args); WriteUpHype(pane); num_args = 0; XtSetArg(args[num_args], XmNscrollingPolicy, XmAUTOMATIC); num_args++; XtSetArg(args[num_args], XmNheight, 500); num_args++; sw = XtCreateManagedWidget("pane", xmScrolledWindowWidgetClass, pane, args, num_args); BuildHierarchy(sw, xmOutlineWidgetClass); MakeControlPanel(pane); InitializePanel(pane); } XtRealizeWidget(top); /* Process events, unwrapping correctly. */ while (!done) { XEvent event; XtAppNextEvent(app_con, &event); XtDispatchEvent(&event); } XtDestroyWidget(top); XtDestroyApplicationContext(app_con); exit(0); }
void BVHAccel::Init(const std::deque<Mesh *> &meshes, const unsigned int totalVertexCount, const unsigned int totalTriangleCount) { assert (!initialized); preprocessedMesh = TriangleMesh::Merge(totalVertexCount, totalTriangleCount, meshes, &preprocessedMeshIDs, &preprocessedMeshTriangleIDs); assert (preprocessedMesh->GetTotalVertexCount() == totalVertexCount); assert (preprocessedMesh->GetTotalTriangleCount() == totalTriangleCount); LR_LOG(ctx, "Total vertices memory usage: " << totalVertexCount * sizeof(Point) / 1024 << "Kbytes"); LR_LOG(ctx, "Total triangles memory usage: " << totalTriangleCount * sizeof(Triangle) / 1024 << "Kbytes"); const Point *v = preprocessedMesh->GetVertices(); const Triangle *p = preprocessedMesh->GetTriangles(); std::vector<BVHAccelTreeNode *> bvList; for (unsigned int i = 0; i < totalTriangleCount; ++i) { BVHAccelTreeNode *ptr = new BVHAccelTreeNode(); ptr->bbox = p[i].WorldBound(v); // NOTE - Ratow - Expand bbox a little to make sure rays collide ptr->bbox.Expand(MachineEpsilon::E(ptr->bbox)); ptr->primitive = i; ptr->leftChild = NULL; ptr->rightSibling = NULL; bvList.push_back(ptr); } LR_LOG(ctx, "Building Bounding Volume Hierarchy, primitives: " << totalTriangleCount); nNodes = 0; BVHAccelTreeNode *rootNode = BuildHierarchy(bvList, 0, bvList.size(), 2); LR_LOG(ctx, "Pre-processing Bounding Volume Hierarchy, total nodes: " << nNodes); bvhTree = new BVHAccelArrayNode[nNodes]; BuildArray(rootNode, 0); FreeHierarchy(rootNode); LR_LOG(ctx, "Total BVH memory usage: " << nNodes * sizeof(BVHAccelArrayNode) / 1024 << "Kbytes"); LR_LOG(ctx, "Finished building Bounding Volume Hierarchy array"); initialized = true; }
vector<vector<DotNode*> > runModularity(DotGraph& g, bool contiguity) { // initialize clusters Cluster* rootCluster = new Cluster(); for (int i = 0; i < (int)g.nodes.size(); i++) rootCluster->addVertex(i); // run modularity rootCluster = BuildHierarchy(CreateBinaryGraph(g, contiguity), rootCluster, contiguity); vector<vector<DotNode*> > res; if (rootCluster->containsVertices()) { vector<int> v = rootCluster->extractAllVertices(); vector<DotNode*> resn; for (int i = 0; i < (int)v.size(); i++) resn.push_back(g.nodes[v[i]]); res.push_back(resn); } else { vector<Cluster*> cl = rootCluster->getSubClusters(); for (int k = 0; k < (int)cl.size(); k++) { vector<int> v = cl[k]->extractAllVertices(); vector<DotNode*> resn; for (int i = 0; i < (int)v.size(); i++) resn.push_back(g.nodes[v[i]]); res.push_back(resn); } } delete rootCluster; return res; }
void ColladaMeshFactory::BuildHierarchy(FCDocument* aColladaDocument,RevModel** aModelNode, FCDSceneNode* aSceneNode) { FCDSceneNode* sceneRoot=aSceneNode; assert(sceneRoot!=NULL); assert(sceneRoot->GetTransformCount()==0); assert(sceneRoot->GetType()==FCDEntity::SCENE_NODE); assert(sceneRoot->GetInstanceCount()<2); if(sceneRoot->GetInstanceCount()==0) { // aModelNode->myIsNULLObject=true; // aModel->myOrientation.myMatrix[0][0]=-1; // aModel->myOrientation.myMatrix[2][2]=-1; } else { FCDEntity::Type t = sceneRoot->GetInstance(0)->GetEntityType(); bool isGeometry = t == FCDEntity::GEOMETRY || FCDEntity::CONTROLLER ? true : false; if( isGeometry ) { bool haveBones = t == FCDEntity::CONTROLLER ? true : false; if( haveBones ) { (*aModelNode)->SetModelType( RevModel::_ANIMATED ); } else { (*aModelNode)->SetModelType( RevModel::_NORMAL ); } FindAndDecodeInstance(aModelNode,sceneRoot->GetInstance(0),aColladaDocument,haveBones); if( haveBones ) { FCDControllerLibrary* controllerLibrary=aColladaDocument->GetControllerLibrary(); for (unsigned int i=0; i< controllerLibrary->GetEntityCount(); i++) { if(controllerLibrary->GetEntity(i)->GetDaeId()==aSceneNode->GetInstance(0)->GetEntity()->GetDaeId()) { BuildBoneHierarchy(*aModelNode,aColladaDocument,aColladaDocument->GetVisualSceneInstance(),-1,dynamic_cast<FCDController*>(controllerLibrary->GetEntity(i)),dynamic_cast<FCDControllerInstance*>(aSceneNode->GetInstance(0)), false); } } } } } for(unsigned int childIndex=0;childIndex<sceneRoot->GetChildrenCount();childIndex++) { FCDSceneNode* childNode; RevModel * childModelNode= new RevModel(); childNode=sceneRoot->GetChild(childIndex); childModelNode->SetModelFilePath((*aModelNode)->GetModelFilePath()); // childModelNode->SetTransformation(GetTransForm(childNode)); (*aModelNode)->AddChild(childModelNode); // (aColladaDocument,childNode,childModelNode); BuildHierarchy(aColladaDocument,&childModelNode, childNode); } }