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);
}
}
