void SimpleDotVisitor::handle(osg::StateSet& stateset, int id) {
std::stringstream label;
label << "<top> " << stateset.className();
if ( !stateset.getName().empty() ) { label << "| " << stateset.getName(); }
drawNode( id, "Mrecord", "solid", label.str(), "green", "white" );
}
void SimpleDotVisitor::handle(osg::Drawable& drawable, int id) {
std::stringstream label;
label << "<top> " << drawable.className();
if ( !drawable.getName().empty() ) { label << "| " << drawable.getName(); }
drawNode( id, "record", "solid", label.str(), "blue", "white" );
}
void SimpleDotVisitor::handle(osg::Group& node, int id) {
std::stringstream label;
label << "<top> " << node.className();
if ( !node.getName().empty() ) { label << "| " << node.getName(); }
drawNode( id, "record", "solid", label.str(), "black", "white" );
}
void drawB3D(B3DFile* b3d) {
drawNode( getNODEChunkFromBB3DChunk( getBB3DChunkFromFile(b3d) ) );
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
void OcclusionCullingTreeBuilder::testNode(OCRenderTreeNode *pNode,
DrawEnv &denv,
RenderPartitionBase *part,
Real32 &scr_percent)
{
while (pNode != NULL)
{
//MATRIX SETUP
UInt32 uiNextMatrix = pNode->getMatrixStore().first;
if(uiNextMatrix != 0 && uiNextMatrix != _uiActiveMatrix)
{
glLoadMatrixf(pNode->getMatrixStore().second.getValues());
_uiActiveMatrix = uiNextMatrix;
_currMatrix.second = pNode->getMatrixStore().second;
updateTopMatrix(denv);
denv.setObjectToWorld(_accMatrix);
++part->_uiNumMatrixChanges;
}
const BoxVolume &volume = pNode->getVolume();
Pnt3f min,max;
volume.getBounds(min, max);
Pnt3f p[8];
p[0].setValues(min[0],min[1],min[2]);
p[1].setValues(max[0],min[1],min[2]);
p[2].setValues(min[0],max[1],min[2]);
p[3].setValues(min[0],min[1],max[2]);
p[4].setValues(max[0],max[1],min[2]);
p[5].setValues(max[0],min[1],max[2]);
p[6].setValues(min[0],max[1],max[2]);
p[7].setValues(max[0],max[1],max[2]);
//std::cout << "OtoW:" << std::endl;
//std::cout << denv.getObjectToWorld() << std::endl;
//std::cout << "WtoC:" << std::endl;
//std::cout << worldToCam << std::endl;
for(UInt32 i = 0; i<8;i++)
{
// std::cout << p[i] << "=>";
denv.getObjectToWorld().mult (p[i], p[i]);
_worldToScreen .multFull(p[i], p[i]);
//std::cout << p[i] << " ";
}
min=p[0];
max=p[0];
for(UInt32 i = 0; i<8; i++)
{
for(UInt32 j=0; j<2; j++)
{
if(p[i][j] < min[j])
{
min[j] = p[i][j];
}
if(p[i][j] > max[j])
{
max[j] = p[i][j];
}
}
}
max[0] = osgClamp(-1.f, max[0], 1.f);
max[1] = osgClamp(-1.f, max[1], 1.f);
min[0] = osgClamp(-1.f, min[0], 1.f);
min[1] = osgClamp(-1.f, min[1], 1.f);
// cbb is the percent of the screen real estate this would cover
Real32 cbb = (max[0] - min[0]) * (max[1] - min[1]) / 4.f;
//std::cout << cur_node << ":" << pix << " ";
//std::cout << pNode->getScalar() << std::endl;
//Make decision
if(pNode->hasFunctor() == false) //Nothing to do
{
//renderNode
drawNode(pNode, denv, part);
}
else
{
//make decision
//if(0 > 1)
if(cbb > scr_percent) // Rendering major occluders
{
drawNode(pNode, denv, part);
//scr_percent+=cbb;
}
else
{
Real32 pcov;
pcov = sqrt(scr_percent) - sqrt(cbb);
pcov *= pcov;
//std::cout << "cbb:" << cbb << " scr_percent:" << scr_percent <<" pcov:" << pcov << std::endl;
//if(scr_percent - pcov > 0.001)
if(pcov > _coveredProbThreshold || cbb < 0.001) // If within threshold or reall small
{
//Get triangles
DrawableStatsAttachment *st =
DrawableStatsAttachment::get(pNode->getNode()->getCore());
st->validate();
UInt32 triangles = st->getTriangles();
if(cbb * _vpWidth * _vpHeight < _minFeatureSize) //small feature culling
{
StatCollector *sc = _ract->getStatCollector();
if(sc != NULL)
sc->getElem(statNOccTriangles)->
add(triangles);
if(_ract->getOcclusionCullingDebug() && pNode->getNode())
{
pNode->getNode()->setTravMask(
pNode->getNode()->getTravMask() |
_ract->getOcclusionCulledDebugMask()
);
}
pNode->setIsRendered(true);
}
else if( triangles <= _minTriangleCount )
{
drawNode(pNode, denv, part);
}
else if((_testPendingNodes.size() == _numTestSamples - 1)) // Make sure we have room to draw a test
{
drawTestResults(denv, part);
if(_testPendingNodes.size() == _numTestSamples - 1) // If we are waiting on a result, draw a node
{
drawNode(pNode, denv, part);
}
else
{
drawTestNode(pNode, denv, part); // Made room, go ahead and draw a test node
}
}
else
{
drawTestNode(pNode, denv, part); //Plenty of room in buffer to draw a test node
}
}
else
{
drawNode(pNode, denv, part); // Probably not being covered up...draw the real node
//scr_percent+=cbb;
}
}
scr_percent += ((1.0 - scr_percent) * cbb);
}
//DRAW CHILDREN OR GO TO TOP AND DO IT AGAIN
if(pNode->getFirstChild() != NULL)
{
OCRenderTreeNode *child =
static_cast<OCRenderTreeNode *>(pNode->getFirstChild());
testNode(child, denv, part, scr_percent);
}
pNode = static_cast<OCRenderTreeNode *>(pNode->getBrother());
}
}
/**
Draw a tree.
\param node Node
\param draw_blends If true, only objects that use blending are drawn. Otherwise objects with
blending are not drawn.
\return True if the tree contained one or more objects that use blending
*/
bool GLRenderInstance::drawNode(WorldObject& node, bool draw_blends)
{
double M[16];
BoundingBox bb;
vec3d bmin, bmax, t, d;
bool render_flag = true;
bool res = false;
WorldObject::ChildIterator it;
for(it=node.childsBegin(); it!=node.childsEnd(); it++)
{
glPushMatrix();
// Set the local transformation
it->second->localTransform().toList(M);
glMultMatrixd(M);
// Draw the geom (if visible)
boost::shared_ptr<GeomObject> geom = it->second->getGeom();
if (geom.get()!=0 && (it->second->visible.getValue()))
{
// Render by default if draw_blends is false
render_flag = !draw_blends;
// Set material
boost::shared_ptr<Material> mat = it->second->getMaterial();
Material* bmat = dynamic_cast<Material*>(mat.get());
// Check if the object should be postponed because blending is used...
if (bmat!=0)
{
if (bmat->usesBlending())
{
res = true;
render_flag = draw_blends;
}
}
if (render_flag)
{
// Set material
glPushAttrib(GL_LIGHTING_BIT | GL_TEXTURE_BIT);
if (bmat!=0)
{
bmat->applyGL();
}
if (draw_solid)
{
clearGLError();
geom->drawGL();
}
// Draw bounding box
if (draw_bboxes)
{
bb = geom->boundingBox();
if (!bb.isEmpty())
{
glDisable(GL_LIGHTING);
bb.getBounds(bmin, bmax);
t = 0.5*(bmax+bmin);
d = bmax-bmin;
glPushMatrix();
glTranslated(t.x, t.y, t.z);
drawWireCube(d.x, d.y, d.z);
glPopMatrix();
glEnable(GL_LIGHTING);
}
}
glPopAttrib(); // restore material
}
}
// Draw the children
res |= drawNode(*(it->second), draw_blends);
glPopMatrix();
}
return res;
}
void
LPESimplify::generateHelperPathAndSmooth(Geom::PathVector &result)
{
if(steps < 1) {
return;
}
Geom::PathVector tmp_path;
Geom::CubicBezier const *cubic = NULL;
for (Geom::PathVector::iterator path_it = result.begin(); path_it != result.end(); ++path_it) {
if (path_it->empty()) {
continue;
}
Geom::Path::iterator curve_it1 = path_it->begin(); // incoming curve
Geom::Path::iterator curve_it2 = ++(path_it->begin());// outgoing curve
Geom::Path::iterator curve_endit = path_it->end_default(); // this determines when the loop has to stop
SPCurve *nCurve = new SPCurve();
if (path_it->closed()) {
// if the path is closed, maybe we have to stop a bit earlier because the
// closing line segment has zerolength.
const Geom::Curve &closingline =
path_it->back_closed(); // the closing line segment is always of type
// Geom::LineSegment.
if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
// closingline.isDegenerate() did not work, because it only checks for
// *exact* zero length, which goes wrong for relative coordinates and
// rounding errors...
// the closing line segment has zero-length. So stop before that one!
curve_endit = path_it->end_open();
}
}
if(helper_size > 0) {
drawNode(curve_it1->initialPoint());
}
nCurve->moveto(curve_it1->initialPoint());
Geom::Point start = Geom::Point(0,0);
while (curve_it1 != curve_endit) {
cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
Geom::Point point_at1 = curve_it1->initialPoint();
Geom::Point point_at2 = curve_it1->finalPoint();
Geom::Point point_at3 = curve_it1->finalPoint();
Geom::Point point_at4 = curve_it1->finalPoint();
if(start == Geom::Point(0,0)) {
start = point_at1;
}
if (cubic) {
point_at1 = (*cubic)[1];
point_at2 = (*cubic)[2];
}
if(path_it->closed() && curve_it2 == curve_endit) {
point_at4 = start;
}
if(curve_it2 != curve_endit) {
cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it2);
if (cubic) {
point_at4 = (*cubic)[1];
}
}
Geom::Ray ray1(point_at2, point_at3);
Geom::Ray ray2(point_at3, point_at4);
double angle1 = Geom::deg_from_rad(ray1.angle());
double angle2 = Geom::deg_from_rad(ray2.angle());
if((smooth_angles >= std::abs(angle2 - angle1)) && !are_near(point_at4,point_at3) && !are_near(point_at2,point_at3)) {
double dist = Geom::distance(point_at2,point_at3);
Geom::Angle angleFixed = ray2.angle();
angleFixed -= Geom::Angle::from_degrees(180.0);
point_at2 = Geom::Point::polar(angleFixed, dist) + point_at3;
}
nCurve->curveto(point_at1, point_at2, curve_it1->finalPoint());
cubic = dynamic_cast<Geom::CubicBezier const *>(nCurve->last_segment());
if (cubic) {
point_at1 = (*cubic)[1];
point_at2 = (*cubic)[2];
if(helper_size > 0) {
if(!are_near((*cubic)[0],(*cubic)[1])) {
drawHandle((*cubic)[1]);
drawHandleLine((*cubic)[0],(*cubic)[1]);
}
if(!are_near((*cubic)[3],(*cubic)[2])) {
drawHandle((*cubic)[2]);
drawHandleLine((*cubic)[3],(*cubic)[2]);
}
}
}
if(helper_size > 0) {
drawNode(curve_it1->finalPoint());
}
++curve_it1;
++curve_it2;
}
if (path_it->closed()) {
nCurve->closepath_current();
}
tmp_path.push_back(nCurve->get_pathvector()[0]);
nCurve->reset();
delete nCurve;
}
result = tmp_path;
}
