FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Moved the osg::ClusterCullingCallback into into own header and source file.

Browse Source
This commit is contained in:
Robert Osfield
2004-06-07 15:05:22 +00:00
parent 48d671352d
commit eec378a885
6 changed files with 229 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
src/osg/Drawable.cpp
View File

@@ -977,161 +977,3 @@ void Drawable::Extensions::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *
else
osg::notify(osg::WARN) << "Error: glGetQueryObjectuiv not supported by OpenGL driver" << std::endl;
}
///////////////////////////////////////////////////////////////////////////////////////////
//
// 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),_deviation(ccc._deviation)
{
}
ClusterCullingCallback::ClusterCullingCallback(const osg::Vec3& controlPoint, const osg::Vec3& normal, float deviation):
_controlPoint(controlPoint),_normal(normal), _deviation(deviation)
{
}
ClusterCullingCallback::ClusterCullingCallback(const osg::Drawable* drawable)
{
computeFrom(drawable);
}
struct ComputeAveragesFunctor
{
ComputeAveragesFunctor():
_num(0),
_x(0.0),_y(0.0),_z(0),
_nx(0.0),_ny(0.0),_nz(0) {}
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)
{
_nx += normal.x();
_ny += normal.y();
_nz += normal.z();
}
_x += v1.x();
_y += v1.y();
_z += v1.z();
_x += v2.x();
_y += v2.y();
_z += v2.z();
_x += v3.x();
_y += v3.y();
_z += v3.z();
++_num;
}
osg::Vec3 center() const { return osg::Vec3(_x/(double)(3*_num),_y/(double)(3*_num),_z/(double)(3*_num)); }
osg::Vec3 normal() const { Vec3 normal(_nx/(double)_num,_ny/(double)_num,_nz/(double)_num); normal.normalize(); return normal; }
unsigned int _num;
double _x,_y,_z;
double _nx,_ny,_nz;
};
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::notify(osg::NOTICE)<<"ClusterCullingCallback::computeFrom() _controlPoint="<<_controlPoint<<std::endl;
// osg::notify(osg::NOTICE)<<" _normal="<<_normal<<std::endl;
// osg::notify(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)
{
_controlPoint = controlPoint;
_normal = normal;
_deviation = deviation;
}
bool ClusterCullingCallback::cull(osg::NodeVisitor* nv, osg::Drawable* , osg::State*) const
{
if (_deviation<=-1.0f)
{
// osg::notify(osg::NOTICE)<<"ClusterCullingCallback::cull() _deviation="<<_deviation<<std::endl;
return false;
}
osg::Vec3 eye_cp = nv->getEyePoint() - _controlPoint;
float deviation = (eye_cp * _normal)/eye_cp.length();
// osg::notify(osg::NOTICE)<<"ClusterCullingCallback::cull() _normal="<<_normal<<" _controlPointtest="<<_controlPoint<<" eye_cp="<<eye_cp<<std::endl;
// osg::notify(osg::NOTICE)<<" deviation="<<deviation<<" _deviation="<<_deviation<<" test="<<(deviation < _deviation)<<std::endl;
return deviation < _deviation;
}