Robert,
Attached is a change to ClusterCullingCallback to make it work properly
under an RTT camera with an INHERIT_VIEWPOINT reference frame.
Glenn Waldron / Pelican Mapping / @glennwaldron
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* OpenSceneGraph Public License for more details.
*/
#include <osg/ClusterCullingCallback>
#include <osg/TriangleFunctor>
#include <osg/CullSettings>
using namespace osg;
///////////////////////////////////////////////////////////////////////////////////////////
//
// Cluster culling callback
//
ClusterCullingCallback::ClusterCullingCallback():
_radius(-1.0f),
_deviation(-1.0f)
{
}
ClusterCullingCallback::ClusterCullingCallback(const ClusterCullingCallback& ccc,const CopyOp& copyop):
Drawable::CullCallback(ccc,copyop),
_controlPoint(ccc._controlPoint),
_normal(ccc._normal),
_radius(ccc._radius),
_deviation(ccc._deviation)
{
}
ClusterCullingCallback::ClusterCullingCallback(const osg::Vec3& controlPoint, const osg::Vec3& normal, float deviation):
_controlPoint(controlPoint),
_normal(normal),
_radius(-1.0f),
_deviation(deviation)
{
}
ClusterCullingCallback::ClusterCullingCallback(const osg::Drawable* drawable)
{
computeFrom(drawable);
}
struct ComputeAveragesFunctor
{
ComputeAveragesFunctor():
_num(0) {}
inline void operator() ( const osg::Vec3 &v1, const osg::Vec3 &v2, const osg::Vec3 &v3, bool)
{
// calc orientation of triangle.
osg::Vec3d normal = (v2-v1)^(v3-v1);
if (normal.normalize()!=0.0f)
{
_normal += normal;
}
_center += v1;
_center += v2;
_center += v3;
++_num;
}
osg::Vec3 center() { return _center / (double)(3*_num); }
osg::Vec3 normal() { _normal.normalize(); return _normal; }
unsigned int _num;
Vec3d _center;
Vec3d _normal;
};
struct ComputeDeviationFunctor
{
ComputeDeviationFunctor():
_deviation(1.0),
_radius2(0.0) {}
void set(const osg::Vec3& center,const osg::Vec3& normal)
{
_center = center;
_normal = normal;
}
inline void operator() ( const osg::Vec3 &v1, const osg::Vec3 &v2, const osg::Vec3 &v3, bool)
{
// calc orientation of triangle.
osg::Vec3 normal = (v2-v1)^(v3-v1);
if (normal.normalize()!=0.0f)
{
_deviation = osg::minimum(_normal*normal,_deviation);
}
_radius2 = osg::maximum((v1-_center).length2(),_radius2);
_radius2 = osg::maximum((v2-_center).length2(),_radius2);
_radius2 = osg::maximum((v3-_center).length2(),_radius2);
}
osg::Vec3 _center;
osg::Vec3 _normal;
float _deviation;
float _radius2;
};
void ClusterCullingCallback::computeFrom(const osg::Drawable* drawable)
{
TriangleFunctor<ComputeAveragesFunctor> caf;
drawable->accept(caf);
_controlPoint = caf.center();
_normal = caf.normal();
TriangleFunctor<ComputeDeviationFunctor> cdf;
cdf.set(_controlPoint,_normal);
drawable->accept(cdf);
// OSG_NOTICE<<"ClusterCullingCallback::computeFrom() _controlPoint="<<_controlPoint<<std::endl;
// OSG_NOTICE<<" _normal="<<_normal<<std::endl;
// OSG_NOTICE<<" cdf._deviation="<<cdf._deviation<<std::endl;
if (_normal.length2()==0.0) _deviation = -1.0f;
else
{
float angle = acosf(cdf._deviation)+osg::PI*0.5f;
if (angle<osg::PI) _deviation = cosf(angle);
else _deviation = -1.0f;
}
_radius = sqrtf(cdf._radius2);
}
void ClusterCullingCallback::set(const osg::Vec3& controlPoint, const osg::Vec3& normal, float deviation, float radius)
{
_controlPoint = controlPoint;
_normal = normal;
_deviation = deviation;
_radius = radius;
}
void ClusterCullingCallback::transform(const osg::Matrixd& matrix)
{
_controlPoint = Vec3d(_controlPoint)*matrix;
_normal = Matrixd::transform3x3(Matrixd::inverse(matrix),Vec3d(_normal));
_normal.normalize();
}
bool ClusterCullingCallback::cull(osg::NodeVisitor* nv, osg::Drawable* , osg::State*) const
{
CullSettings* cs = dynamic_cast<CullSettings*>(nv);
if (cs && !(cs->getCullingMode() & CullSettings::CLUSTER_CULLING))
{
// cluster culling switched off cull settings.
return false;
}
if (_deviation<=-1.0f)
{
// cluster culling switch off by deviation.
return false;
}
osg::Vec3 eye_cp = nv->getViewPoint() - _controlPoint;
float radius = eye_cp.length();
if (radius<_radius)
{
return false;
}
float deviation = (eye_cp * _normal)/radius;
// OSG_NOTICE<<"ClusterCullingCallback::cull() _normal="<<_normal<<" _controlPointtest="<<_controlPoint<<" eye_cp="<<eye_cp<<std::endl;
// OSG_NOTICE<<" deviation="<<deviation<<" _deviation="<<_deviation<<" test="<<(deviation < _deviation)<<std::endl;
return deviation < _deviation;
}
void ClusterCullingCallback::operator()(Node* node, NodeVisitor* nv)
{
if (nv)
{
if (cull(nv,0,static_cast<State *>(0))) return;
traverse(node,nv);
}
}
_______________________________________________
osg-submissions mailing list
[email protected]
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
