void GlMetaNodeRenderer::render(node n, float, Camera *camera) {
bool viewMeta = _inputData->renderingParameters()
->isDisplayMetaNodes(); // Checks if user wants to see metanode content
bool viewMetaLabels =
_inputData->renderingParameters()
->isViewMetaLabel(); // Checks if user wants to see metanode content labels
if (!viewMeta && !viewMetaLabels) {
return;
}
GLint renderMode;
glGetIntegerv(GL_RENDER_MODE, &renderMode);
if (renderMode == GL_SELECT)
return;
Graph *metaGraph = _inputData->getGraph()->getNodeMetaInfo(n);
GlScene *scene = nullptr;
if (_metaGraphToSceneMap.count(metaGraph) != 0) {
scene = _metaGraphToSceneMap[metaGraph];
} else {
scene = createScene(metaGraph);
assert(scene != nullptr);
_metaGraphToSceneMap[metaGraph] = scene;
metaGraph->addListener(this);
}
scene->getGlGraphComposite()->setRenderingParameters(*(_inputData->renderingParameters()));
int metaStencil = _inputData->renderingParameters()->getMetaNodesStencil();
int metaSelectedStencil = _inputData->renderingParameters()->getSelectedMetaNodesStencil();
int metaLabelStencil = _inputData->renderingParameters()->getMetaNodesLabelStencil();
scene->getGlGraphComposite()->getRenderingParametersPointer()->setDisplayNodes(viewMeta);
scene->getGlGraphComposite()->getRenderingParametersPointer()->setDisplayEdges(viewMeta);
scene->getGlGraphComposite()->getRenderingParametersPointer()->setViewEdgeLabel(viewMetaLabels);
scene->getGlGraphComposite()->getRenderingParametersPointer()->setViewNodeLabel(viewMetaLabels);
scene->getGlGraphComposite()->getRenderingParametersPointer()->setNodesStencil(metaStencil);
scene->getGlGraphComposite()->getRenderingParametersPointer()->setEdgesStencil(metaStencil);
scene->getGlGraphComposite()->getRenderingParametersPointer()->setSelectedNodesStencil(
metaSelectedStencil);
scene->getGlGraphComposite()->getRenderingParametersPointer()->setSelectedEdgesStencil(
metaSelectedStencil);
scene->getGlGraphComposite()->getRenderingParametersPointer()->setNodesLabelStencil(
metaLabelStencil);
scene->getGlGraphComposite()->getRenderingParametersPointer()->setEdgesLabelStencil(
metaLabelStencil);
GlNode glNode(n.id);
BoundingBox includeBB;
_inputData->glyphs.get(_inputData->getElementShape()->getNodeValue(n))
->getIncludeBoundingBox(includeBB, n);
BoundingBox &&bbTmp = glNode.getBoundingBox(_inputData);
BoundingBox bb(bbTmp.center() - Coord((bbTmp.width() / 2.f) * (includeBB[0][0] * -2.f),
(bbTmp.height() / 2.f) * (includeBB[0][1] * -2.f),
(bbTmp.depth() / 2.f) * (includeBB[0][2] * -2.f)),
bbTmp.center() + Coord((bbTmp.width() / 2.f) * (includeBB[1][0] * 2.f),
(bbTmp.height() / 2.f) * (includeBB[1][1] * 2.f),
(bbTmp.depth() / 2.f) * (includeBB[1][2] * 2.f)));
Coord eyeDirection = camera->getEyes() - camera->getCenter();
eyeDirection = eyeDirection / eyeDirection.norm();
Camera newCamera2(*camera);
newCamera2.setEyes(newCamera2.getCenter() +
Coord(0, 0, 1) * (newCamera2.getEyes() - newCamera2.getCenter()).norm());
newCamera2.setUp(Coord(0, 1, 0));
Coord center = camera->worldTo2DViewport((bb[0] + bb[1]) / 2.f);
Coord &&first = newCamera2.worldTo2DViewport(bb[0]);
Coord &&second = newCamera2.worldTo2DViewport(bb[1]);
Coord &&size = second - first;
Vector<int, 4> viewport;
viewport[0] = center[0] - size[0] / 2;
viewport[1] = center[1] - size[1] / 2;
viewport[2] = size[0];
viewport[3] = size[1];
viewport[0] = camera->getViewport()[0] + viewport[0] - viewport[2] / 2;
viewport[1] = camera->getViewport()[1] + viewport[1] - viewport[3] / 2;
viewport[2] *= 2;
viewport[3] *= 2;
if (viewport[2] == 0 || viewport[3] == 0)
return;
scene->setViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
scene->setClearBufferAtDraw(false);
scene->setClearDepthBufferAtDraw(false);
scene->setClearStencilBufferAtDraw(false);
scene->centerScene();
float baseNorm = (scene->getGraphLayer()->getCamera().getEyes() -
scene->getGraphLayer()->getCamera().getCenter())
.norm();
Camera newCamera = scene->getGraphLayer()->getCamera();
Camera *oldCamera = new Camera(scene, true);
newCamera.setScene(scene);
*oldCamera = newCamera;
newCamera.setUp(camera->getUp());
newCamera.setEyes(newCamera.getCenter() + (eyeDirection * baseNorm));
newCamera.setZoomFactor(newCamera.getZoomFactor() * 0.5);
scene->getGraphLayer()->setSharedCamera(&newCamera);
// small hack to avoid z-fighting between the rendering of the metanode content
// and the rendering of the metanode that occurs afterwards
glDepthRange(0.1, 1);
scene->draw();
// restore default depth range
glDepthRange(0, 1);
scene->getGraphLayer()->setCamera(oldCamera);
camera->getScene()->setClearBufferAtDraw(false);
camera->getScene()->setClearDepthBufferAtDraw(false);
camera->getScene()->setClearStencilBufferAtDraw(false);
camera->getScene()->initGlParameters();
camera->getScene()->setClearBufferAtDraw(true);
camera->getScene()->setClearDepthBufferAtDraw(true);
camera->getScene()->setClearStencilBufferAtDraw(true);
camera->initGl();
}
void GlMetaNodeTrueRenderer::render(node n,float lod,Camera* camera) {
if(GlMetaNodeTrueRenderer::depth>=10000)
return;
if(lod<10)
return;
GlGraphInputData *inputDataBackup=inputData;
inputData->getGlVertexArrayManager()->pauseRendering(true);
glPushMatrix();
const Coord &nodeCoord = inputData->getElementLayout()->getNodeValue(n);
const Size &nodeSize = inputData->getElementSize()->getNodeValue(n);
glTranslatef(nodeCoord[0], nodeCoord[1], nodeCoord[2]);
glRotatef(static_cast<float>(inputData->getElementRotation()->getNodeValue(n)), 0.f, 0.f, 1.f);
Graph *metaGraph = inputData->getGraph()->getNodeMetaInfo(n);
GlGraphRenderingParameters metaParameters = *inputData->parameters;
GlGraphInputData metaData(metaGraph,&metaParameters);
metaData.setMetaNodeRenderer(inputData->getMetaNodeRenderer());
metaData.setDeleteMetaNodeRendererAtDestructor(false);
BoundingBox bboxes = tlp::computeBoundingBox(metaData.getGraph(), metaData.getElementLayout(), metaData.getElementSize(), metaData.getElementRotation());
Coord maxC(bboxes[1]);
Coord minC(bboxes[0]);
BoundingBox includeBoundingBox;
inputData->glyphs.get(inputData->getElementShape()->getNodeValue(n))->getIncludeBoundingBox(includeBoundingBox,n);
Coord includeScale(includeBoundingBox[1] - includeBoundingBox[0]);
Coord includeTranslate(includeBoundingBox.center());
Coord translate( (maxC+minC)/-2.f);
double dept;
if(includeScale[2]==0)
dept=0;
else
dept= (maxC[2] - minC[2]) / includeScale[2];
double width = (maxC[0] - minC[0]) / includeScale[0];
double height = (maxC[1] - minC[1]) / includeScale[1];
Coord includeSize(bboxes[1] - bboxes[0]);
if(nodeSize[0]/includeSize[0]<nodeSize[1]/includeSize[1]) {
includeSize[1]*=nodeSize[0]/includeSize[0];
includeSize[0]*=nodeSize[0]/includeSize[0];
}
else {
includeSize[0]*=nodeSize[1]/includeSize[1];
includeSize[1]*=nodeSize[1]/includeSize[1];
}
if(includeSize[2]!=0)
includeSize[2]*=nodeSize[2]/includeSize[2];
glScalef(includeSize[0], includeSize[1], includeSize[2]);
glTranslatef(includeTranslate[0],includeTranslate[1],includeTranslate[2]-static_cast<float>(width/1000.));
if (width<0.0001) width=1;
if (height<0.0001) height=1;
if (dept<0.0001) dept=1;
Coord scale(static_cast<float>(1/width),static_cast<float>(1/height),static_cast<float>(1/dept));
Camera *activeCamera;
vector<Coord> objectScale, objectTranslate, objectCoord;
activeCamera=new Camera(*camera);
activeCamera->addObjectTransformation(nodeCoord+translate, Coord(includeSize*scale), nodeCoord);
activeCamera->getObjectTransformation(objectTranslate, objectScale, objectCoord);
GlCPULODCalculator calculator;
calculator.setRenderingEntitiesFlag(RenderingAll);
calculator.beginNewCamera(activeCamera);
Iterator<node> *itN=metaGraph->getNodes();
GlNode glNode(0);
while (itN->hasNext()) {
glNode.id=itN->next().id;
BoundingBox bb = glNode.getBoundingBox(&metaData);
Coord size(bb[1] - bb[0]);
Coord middle(bb[0] + size/2.f);
for(int i=objectScale.size()-1; i>=0; --i) {
middle+=objectTranslate[i];
middle=objectCoord[i] - (objectCoord[i]-middle)*objectScale[i];
size*=objectScale[i];
}
bb[0] = middle-size/2.f;
bb[1] = middle+size/2.f;
calculator.addNodeBoundingBox(glNode.id,bb);
}
delete itN;
if (metaData.parameters->isDisplayEdges()) {
Iterator<edge> *itE=metaGraph->getEdges();
GlEdge glEdge(0);
while (itE->hasNext()) {
glEdge.id=itE->next().id;
BoundingBox bb = glEdge.getBoundingBox(&metaData);
Coord size(bb[1] - bb[0]);
Coord middle(bb[0] + (size)/2.f);
for(int i=objectScale.size()-1; i>=0; --i) {
middle+=objectTranslate[i];
middle=objectCoord[i] - (objectCoord[i]-middle)*objectScale[i];
size*=objectScale[i];
}
bb[0] = middle-size/2.f;
bb[1] = middle+size/2.f;
calculator.addEdgeBoundingBox(glEdge.id,bb);
}
delete itE;
}
calculator.compute(camera->getViewport(),camera->getViewport());
LayersLODVector &layersLODVector=calculator.getResult();
LayerLODUnit &layerLODUnit=layersLODVector.front();
glPushMatrix();
glScalef(scale[0],scale[1],scale[2]);
glTranslatef(translate[0],translate[1],translate[2]);
GlMetaNodeTrueRenderer::depth++;
metaData.getMetaNodeRenderer()->setInputData(&metaData);
metaData.getGlVertexArrayManager()->pauseRendering(true);
GlMetaNode glMetaNode(0);
GlEdge glEdge(0);
for(vector<ComplexEntityLODUnit>::iterator it=layerLODUnit.nodesLODVector.begin(); it!=layerLODUnit.nodesLODVector.end(); ++it) {
if((*it).lod<0)
continue;
metaData.getGlVertexArrayManager()->pauseRendering(true);
if(!metaData.getGraph()->isMetaNode(node((*it).id))) {
glNode.id=(*it).id;
glNode.draw((*it).lod,&metaData,activeCamera);
}
else {
glMetaNode.id=(*it).id;
glMetaNode.draw((*it).lod,&metaData,activeCamera);
}
}
metaData.getGlVertexArrayManager()->pauseRendering(true);
for(vector<ComplexEntityLODUnit>::iterator it=layerLODUnit.edgesLODVector.begin(); it!=layerLODUnit.edgesLODVector.end(); ++it) {
if((*it).lod<0)
continue;
glEdge.id=(*it).id;
glEdge.draw((*it).lod,&metaData,activeCamera);
}
metaData.getMetaNodeRenderer()->setInputData(inputDataBackup);
inputData->getGlVertexArrayManager()->pauseRendering(false);
GlMetaNodeTrueRenderer::depth--;
glPopMatrix();
glPopMatrix();
delete activeCamera;
}
