bool CollisionDroiteCercle_BBox(const t_vec2f& A, const t_vec2f& B, const t_vec2f& C, float radius)
{
t_vec2f minAB(std::min(A.x, B.x), std::min(A.y, B.y));
t_vec2f maxAB(std::max(A.x, B.x), std::max(A.y, B.y));
t_vec2f minC(C.x - radius, C.y - radius);
t_vec2f maxC(C.x + radius, C.y + radius);
return !(maxAB.x < minC.x ||
minAB.x > maxC.x ||
maxAB.y < minC.y ||
minAB.y > maxC.y);
}
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;
}
void GlMetaNode::drawLabel(OcclusionTest* test, GlGraphInputData* data, float lod, Camera *camera) {
node n=node(id);
if(data->parameters->isViewNodeLabel())
GlNode::drawLabel(test,data,lod,camera);
if(!data->parameters->isViewMetaLabel())
return;
if(!data->getMetaNodeRenderer()->glMetaNodeHaveToRenderLabels())
return;
if(!data->parameters->isViewMetaLabel())
return;
if((data->getElementColor()->getNodeValue(n))[3]==255) {
return;
}
Graph *metaGraph = data->getGraph()->getNodeMetaInfo(n);
GlGraphRenderingParameters metaParameters = *data->parameters;
GlGraphInputData metaData(metaGraph,&metaParameters);
vector<GlNode> nodes;
vector<GlMetaNode> metaNodes;
vector<GlEdge> edges;
Iterator<node> *itN=metaGraph->getNodes();
unsigned int id;
while (itN->hasNext()) {
id=itN->next().id;
if(metaData.getGraph()->isMetaNode(node(id)))
metaNodes.push_back(GlMetaNode(id));
else
nodes.push_back(GlNode(id));
}
delete itN;
if (metaData.parameters->isDisplayEdges()) {
Iterator<edge> *itE=metaGraph->getEdges();
while (itE->hasNext()) {
edges.push_back(GlEdge(itE->next().id));
}
delete itE;
}
glPushMatrix();
const Coord &nodeCoord = data->getElementLayout()->getNodeValue(n);
const Size &nodeSize = data->getElementSize()->getNodeValue(n);
glTranslatef(nodeCoord[0], nodeCoord[1], nodeCoord[2]);
glRotatef(static_cast<float>(data->getElementRotation()->getNodeValue(n)), 0.f, 0.f, 1.f);
BoundingBox bboxes = tlp::computeBoundingBox(metaData.getGraph(), metaData.getElementLayout(), metaData.getElementSize(), metaData.getElementRotation());
Coord maxC(bboxes[1]);
Coord minC(bboxes[0]);
BoundingBox includeBoundingBox;
data->glyphs.get(data->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];
}
glScalef(includeSize[0], includeSize[1], includeSize[2]);
glTranslatef(includeTranslate[0],includeTranslate[1],includeTranslate[2]);
if (width<0.0001) width=1;
if (height<0.0001) height=1;
if (dept<0.0001) dept=1;
Coord scale(1/static_cast<float>(width),1/static_cast<float>(height),1/static_cast<float>(dept));
glScalef(scale[0], scale[1], scale[2]);
glTranslatef(translate[0],translate[1],translate[2]);
vector<Coord> objectScale, objectTranslate, objectCoord;
Camera *activeCamera=new Camera(*camera);
activeCamera->addObjectTransformation(nodeCoord+translate, Coord(includeSize*scale), nodeCoord);
activeCamera->getObjectTransformation(objectTranslate, objectScale, objectCoord);
for(vector<GlNode>::iterator it=nodes.begin(); it!=nodes.end(); ++it) {
(*it).drawLabel(test,&metaData,1000,camera);
}
for(vector<GlMetaNode>::iterator it=metaNodes.begin(); it!=metaNodes.end(); ++it) {
(*it).drawLabel(test,&metaData,1000,camera);
}
for(vector<GlEdge>::iterator it=edges.begin(); it!=edges.end(); ++it) {
(*it).drawLabel(test,&metaData);
}
glPopMatrix();
}
