590 lines
23 KiB
C++
590 lines
23 KiB
C++
/* -*-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.
|
|
*
|
|
* ViewDependentShadow codes Copyright (C) 2008 Wojciech Lewandowski
|
|
* Thanks to to my company http://www.ai.com.pl for allowing me free this work.
|
|
*/
|
|
|
|
#include <osgShadow/DebugShadowMap>
|
|
#include <osgShadow/ConvexPolyhedron>
|
|
#include <osgUtil/RenderLeaf>
|
|
#include <osg/Geometry>
|
|
#include <osg/PrimitiveSet>
|
|
#include <osg/MatrixTransform>
|
|
#include <osg/Depth>
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
|
|
using namespace osgShadow;
|
|
|
|
|
|
#define VECTOR_LENGTH( v ) ( sizeof(v)/sizeof(v[0]) )
|
|
|
|
#define DEFAULT_DEBUG_HUD_SIZE_X 256
|
|
#define DEFAULT_DEBUG_HUD_SIZE_Y 256
|
|
#define DEFAULT_DEBUG_HUD_ORIGIN_X 8
|
|
#define DEFAULT_DEBUG_HUD_ORIGIN_Y 8
|
|
|
|
DebugShadowMap::DebugShadowMap():
|
|
BaseClass(),
|
|
_doDebugDraw( false ),
|
|
_hudSize( 2, 2 ),
|
|
_hudOrigin( -1, -1 ),
|
|
_viewportSize( DEFAULT_DEBUG_HUD_SIZE_X, DEFAULT_DEBUG_HUD_SIZE_Y ),
|
|
_viewportOrigin( DEFAULT_DEBUG_HUD_ORIGIN_X, DEFAULT_DEBUG_HUD_ORIGIN_Y ),
|
|
_orthoSize( 2, 2 ),
|
|
_orthoOrigin( -1, -1 )
|
|
{
|
|
|
|
// Why this fancy 24 bit depth to 24 bit rainbow colors shader ?
|
|
//
|
|
// Depth values cannot be easily cast on color component because they are:
|
|
// a) 24 or 32 bit and we loose lots of precision when cast on 8 bit
|
|
// b) depth value distribution is non linear due to projection division
|
|
// when cast on componenent color there is usually very minor shade variety
|
|
// and its often difficult to notice that there is anything in the buffer
|
|
//
|
|
// Shader looks complex but it is used only for debug head-up rectangle
|
|
// so performance impact is not significant.
|
|
|
|
_depthColorFragmentShader = new osg::Shader( osg::Shader::FRAGMENT,
|
|
#if 0
|
|
"uniform sampler2D texture; \n"
|
|
" \n"
|
|
"void main(void) \n"
|
|
"{ \n"
|
|
" float f = texture2D( texture, vec3( gl_TexCoord[0].xy, 1.0).xy ).r; \n"
|
|
" gl_FragColor = vec4( 0.0, 1.0 - f, 0.5 - f, 0.5 ); \n"
|
|
"} \n"
|
|
#else
|
|
"uniform sampler2D texture; \n"
|
|
" \n"
|
|
"void main(void) \n"
|
|
"{ \n"
|
|
" float f = texture2D( texture, vec3( gl_TexCoord[0].xy, 1.0).xy ).r; \n"
|
|
" \n"
|
|
" f = 256.0 * f; \n"
|
|
" float fC = floor( f ) / 256.0; \n"
|
|
" \n"
|
|
" f = 256.0 * fract( f ); \n"
|
|
" float fS = floor( f ) / 256.0; \n"
|
|
" \n"
|
|
" f = 256.0 * fract( f ); \n"
|
|
" float fH = floor( f ) / 256.0; \n"
|
|
" \n"
|
|
" fS *= 0.5; \n"
|
|
" fH = ( fH * 0.34 + 0.66 ) * ( 1.0 - fS ); \n"
|
|
" \n"
|
|
" vec3 rgb = vec3( ( fC > 0.5 ? ( 1.0 - fC ) : fC ), \n"
|
|
" abs( fC - 0.333333 ), \n"
|
|
" abs( fC - 0.666667 ) ); \n"
|
|
" \n"
|
|
" rgb = min( vec3( 1.0, 1.0, 1.0 ), 3.0 * rgb ); \n"
|
|
" \n"
|
|
" float fMax = max( max( rgb.r, rgb.g ), rgb.b ); \n"
|
|
" fMax = 1.0 / fMax; \n"
|
|
" \n"
|
|
" vec3 color = fMax * rgb; \n"
|
|
" \n"
|
|
" gl_FragColor = vec4( fS + fH * color, 1 ) * gl_Color; \n"
|
|
"} \n"
|
|
#endif
|
|
); // end _depthColorFragmentShader
|
|
}
|
|
|
|
DebugShadowMap::DebugShadowMap
|
|
(const DebugShadowMap& copy, const osg::CopyOp& copyop) :
|
|
BaseClass(copy,copyop),
|
|
_doDebugDraw( copy._doDebugDraw ),
|
|
_hudSize( copy._hudSize ),
|
|
_hudOrigin( copy._hudOrigin ),
|
|
_viewportSize( copy._viewportSize ),
|
|
_viewportOrigin( copy._viewportOrigin ),
|
|
_orthoSize( copy._viewportOrigin ),
|
|
_orthoOrigin( copy._viewportOrigin )
|
|
{
|
|
if( copy._depthColorFragmentShader.valid() )
|
|
_depthColorFragmentShader =
|
|
dynamic_cast<osg::Shader*>
|
|
( copy._depthColorFragmentShader->clone(copyop) );
|
|
}
|
|
|
|
DebugShadowMap::~DebugShadowMap()
|
|
{
|
|
}
|
|
|
|
void DebugShadowMap::ViewData::cull( void )
|
|
{
|
|
if( getDebugDraw() && !_cameraDebugHUD.valid() )
|
|
createDebugHUD();
|
|
|
|
BaseClass::ViewData::cull( );
|
|
|
|
cullDebugGeometry( );
|
|
}
|
|
|
|
bool DebugShadowMap::ViewData::DebugBoundingBox
|
|
( const osg::BoundingBox & bb, const char * name )
|
|
{
|
|
bool result = false;
|
|
#if defined( _DEBUG ) || defined( DEBUG )
|
|
if( !name ) name = "";
|
|
|
|
osg::BoundingBox & bb_prev = _boundingBoxMap[ std::string( name ) ];
|
|
|
|
result = bb.center() != bb_prev.center() || bb.radius() != bb_prev.radius();
|
|
if( result )
|
|
std::cout << "Box<" << name << "> ("
|
|
<< ( bb._max._v[0] + bb._min._v[0] ) * 0.5 << " "
|
|
<< ( bb._max._v[1] + bb._min._v[1] ) * 0.5 << " "
|
|
<< ( bb._max._v[2] + bb._min._v[2] ) * 0.5 << ") ["
|
|
<< ( bb._max._v[0] - bb._min._v[0] ) << " "
|
|
<< ( bb._max._v[1] - bb._min._v[1] ) << " "
|
|
<< ( bb._max._v[2] - bb._min._v[2] ) << "] "
|
|
<< std::endl;
|
|
|
|
bb_prev = bb;
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
bool DebugShadowMap::ViewData::DebugPolytope
|
|
( const osg::Polytope & p, const char * name )
|
|
{
|
|
bool result = false;
|
|
#if defined( _DEBUG ) || defined( DEBUG )
|
|
if( !name ) name = "";
|
|
|
|
osg::Polytope & p_prev = _polytopeMap[ std::string( name ) ];
|
|
|
|
result = ( p.getPlaneList() != p_prev.getPlaneList() );
|
|
|
|
if( result ) {
|
|
std::cout << "Polytope<" << name
|
|
<< "> size(" << p.getPlaneList().size() << ")"
|
|
<< std::endl;
|
|
|
|
if( p.getPlaneList().size() == p_prev.getPlaneList().size() ) {
|
|
for( unsigned i = 0; i < p.getPlaneList().size(); ++i )
|
|
{
|
|
if( p.getPlaneList()[i] != p_prev.getPlaneList()[i] )
|
|
{
|
|
std::cout << "Plane<" << i
|
|
<< "> ("
|
|
<< p.getPlaneList()[i].asVec4()[0] << ", "
|
|
<< p.getPlaneList()[i].asVec4()[1] << ", "
|
|
<< p.getPlaneList()[i].asVec4()[2] << ", "
|
|
<< p.getPlaneList()[i].asVec4()[3] << ")"
|
|
<< std::endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
p_prev = p;
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
bool DebugShadowMap::ViewData::DebugMatrix
|
|
( const osg::Matrix & m, const char * name )
|
|
{
|
|
bool result = false;
|
|
#if defined( _DEBUG ) || defined( DEBUG )
|
|
if( !name ) name = "";
|
|
|
|
osg::Matrix & m_prev = _matrixMap[ std::string( name ) ];
|
|
|
|
result = ( m != m_prev );
|
|
|
|
if( result )
|
|
std::cout << "Matrix<" << name << "> " << std::endl
|
|
<<"[ " << m(0,0) << " " << m(0,1) << " " << m(0,2) << " " << m(0,3) << " ] " << std::endl
|
|
<<"[ " << m(1,0) << " " << m(1,1) << " " << m(1,2) << " " << m(1,3) << " ] " << std::endl
|
|
<<"[ " << m(2,0) << " " << m(2,1) << " " << m(2,2) << " " << m(2,3) << " ] " << std::endl
|
|
<<"[ " << m(3,0) << " " << m(3,1) << " " << m(3,2) << " " << m(3,3) << " ] " << std::endl;
|
|
|
|
m_prev = m;
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
void DebugShadowMap::ViewData::setDebugPolytope
|
|
( const char * name, const ConvexPolyhedron & polytope,
|
|
osg::Vec4 colorOutline, osg::Vec4 colorInside )
|
|
{
|
|
if( !getDebugDraw() ) return;
|
|
|
|
if( &polytope == NULL ) { // delete
|
|
PolytopeGeometry & pg = _polytopeGeometryMap[ std::string( name ) ];
|
|
for( int i = 0; i < VECTOR_LENGTH( pg._geometry ) ; i++ )
|
|
{
|
|
if( pg._geometry[i].valid() ) {
|
|
if( _geode[i].valid() &&
|
|
_geode[i]->containsDrawable( pg._geometry[i].get() ) )
|
|
_geode[i]->removeDrawable( pg._geometry[i].get() );
|
|
|
|
pg._geometry[i] = NULL;
|
|
}
|
|
}
|
|
_polytopeGeometryMap.erase( std::string( name ) );
|
|
} else { // update
|
|
PolytopeGeometry & pg = _polytopeGeometryMap[ std::string( name ) ];
|
|
|
|
pg._polytope = polytope;
|
|
if( colorOutline.a() > 0 )
|
|
pg._colorOutline = colorOutline;
|
|
if( colorInside.a() > 0 )
|
|
pg._colorInside = colorInside;
|
|
|
|
for( int i = 0; i < VECTOR_LENGTH( pg._geometry ) ; i++ )
|
|
{
|
|
if( !pg._geometry[i].valid() ) {
|
|
pg._geometry[i] = new osg::Geometry;
|
|
pg._geometry[i]->setDataVariance( osg::Object::DYNAMIC );
|
|
pg._geometry[i]->setUseDisplayList( false );
|
|
pg._geometry[i]->setSupportsDisplayList( false );
|
|
}
|
|
|
|
if( _geode[i].valid() &&
|
|
!_geode[i]->containsDrawable( pg._geometry[i].get() ) ) {
|
|
osg::Geode::DrawableList & dl =
|
|
const_cast< osg::Geode::DrawableList &>
|
|
( _geode[i]->getDrawableList() );
|
|
dl.insert( dl.begin(), pg._geometry[i].get() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void DebugShadowMap::ViewData::updateDebugGeometry
|
|
( const osg::Camera * viewCam, const osg::Camera * shadowCam )
|
|
{
|
|
if( !getDebugDraw() ) return;
|
|
if( _polytopeGeometryMap.empty() ) return;
|
|
|
|
const int num = 2; // = VECTOR_LENGTH( PolytopeGeometry::_geometry );
|
|
|
|
const osg::Camera *camera[2] = { viewCam, shadowCam };
|
|
|
|
osg::Matrix
|
|
transform[ num ] =
|
|
{ viewCam->getViewMatrix() *
|
|
// use near far clamped projection ( precomputed in cullDebugGeometry )
|
|
( viewCam == _viewCamera ? _viewProjection : viewCam->getProjectionMatrix() ),
|
|
shadowCam->getViewMatrix() * shadowCam->getProjectionMatrix() },
|
|
inverse[ num ] =
|
|
{ osg::Matrix::inverse( transform[0] ),
|
|
osg::Matrix::inverse( transform[1] ) };
|
|
|
|
#if 0
|
|
ConvexPolyhedron frustum[ num ];
|
|
for( int i = 0; i < num; i++ ) {
|
|
frustum[i].setToUnitFrustum( );
|
|
#if 1
|
|
frustum[i].transform( inverse[i], transform[i] );
|
|
#else
|
|
frustum[i].transform
|
|
( osg::Matrix::inverse( camera[i]->getProjectionMatrix() ),
|
|
camera[i]->getProjectionMatrix() );
|
|
frustum[i].transform
|
|
( osg::Matrix::inverse( camera[i]->getViewMatrix() ),
|
|
camera[i]->getViewMatrix() );
|
|
#endif
|
|
};
|
|
#else
|
|
osg::Polytope frustum[ num ];
|
|
for( int i = 0; i < num; i++ ) {
|
|
frustum[i].setToUnitFrustum( );
|
|
frustum[i].transformProvidingInverse( transform[i] );
|
|
}
|
|
#endif
|
|
|
|
transform[0] = viewCam->getViewMatrix();
|
|
inverse[0] = viewCam->getInverseViewMatrix();
|
|
|
|
for( PolytopeGeometryMap::iterator itr = _polytopeGeometryMap.begin();
|
|
itr != _polytopeGeometryMap.end();
|
|
++itr )
|
|
{
|
|
PolytopeGeometry & pg = itr->second;
|
|
|
|
for( int i = 0; i < num ; i++ )
|
|
{
|
|
|
|
ConvexPolyhedron cp( pg._polytope );
|
|
cp.cut( frustum[i] );
|
|
cp.transform( transform[i], inverse[i] );
|
|
|
|
pg._geometry[i] = cp.buildGeometry
|
|
( pg._colorOutline, pg._colorInside, pg._geometry[i].get() );
|
|
}
|
|
}
|
|
}
|
|
|
|
void DebugShadowMap::ViewData::cullDebugGeometry( )
|
|
{
|
|
if( !getDebugDraw() ) return;
|
|
if( !_camera.valid() ) return;
|
|
|
|
// View camera may use clamping projection matrix after traversal.
|
|
// Since we need to know exact matrix for drawing the frusta,
|
|
// we have to compute it here in exactly the same way as cull visitor
|
|
// will after cull traversal completes view camera subgraph.
|
|
{
|
|
_viewProjection = *_cv->getProjectionMatrix();
|
|
_viewCamera = _cv->getRenderStage()->getCamera();
|
|
|
|
if( _cv->getComputeNearFarMode() ) {
|
|
|
|
// Redo steps from CullVisitor::popProjectionMatrix()
|
|
// which clamps projection matrix when Camera & Projection
|
|
// completes traversal of their children
|
|
|
|
// We have to do this now manually
|
|
// because we did not complete camera traversal yet but
|
|
// we need to know how this clamped projection matrix will be
|
|
|
|
_cv->computeNearPlane();
|
|
|
|
osgUtil::CullVisitor::value_type n = _cv->getCalculatedNearPlane();
|
|
osgUtil::CullVisitor::value_type f = _cv->getCalculatedFarPlane();
|
|
|
|
if( n < f )
|
|
_cv->clampProjectionMatrix( _viewProjection, n, f );
|
|
}
|
|
}
|
|
|
|
updateDebugGeometry( _viewCamera, _camera.get() );
|
|
|
|
#if 1 // Add geometries of polytopes to main cam Render Stage
|
|
_transform[0]->accept( *_cv );
|
|
#else
|
|
for( PolytopeGeometryMap::iterator itr = _polytopeGeometryMap.begin();
|
|
itr != _polytopeGeometryMap.end();
|
|
++itr )
|
|
{
|
|
PolytopeGeometry & pg = itr->second;
|
|
_cv->pushStateSet( _geode[0]->getStateSet() );
|
|
_cv->addDrawableAndDepth( pg._geometry[0].get(), NULL, FLT_MAX );
|
|
_cv->popStateSet( );
|
|
}
|
|
#endif
|
|
|
|
// Add geometries of polytopes to hud cam Render Stage
|
|
_cameraDebugHUD->accept( *_cv );
|
|
}
|
|
|
|
void DebugShadowMap::ViewData::init( ThisClass *st, osgUtil::CullVisitor *cv )
|
|
{
|
|
BaseClass::ViewData::init( st, cv );
|
|
|
|
_doDebugDrawPtr = &st->_doDebugDraw;
|
|
|
|
_hudSize = st->_hudSize;
|
|
_hudOrigin = st->_hudOrigin;
|
|
_viewportSize = st->_viewportSize;
|
|
_viewportOrigin = st->_viewportOrigin;
|
|
_orthoSize = st->_orthoSize;
|
|
_orthoOrigin = st->_orthoOrigin;
|
|
|
|
_depthColorFragmentShader = st->_depthColorFragmentShader;
|
|
|
|
// create placeholder geodeds for polytope geometries
|
|
// rest of their initialization will be performed during camera hud init
|
|
_geode[0] = new osg::Geode;
|
|
_geode[1] = new osg::Geode;
|
|
|
|
_cameraDebugHUD = NULL;//Force debug HUD rebuild ( if needed )
|
|
}
|
|
|
|
// Callback used by debugging hud to display Shadow Map to color buffer
|
|
// Had to do it this way because OSG does not allow to use
|
|
// the same GL Texture Id with different glTexParams.
|
|
// Callback simply turns compare mode off via GL while rendering hud and
|
|
// restores it before rendering the scene with shadows.
|
|
|
|
class DrawableDrawWithDepthShadowComparisonOffCallback:
|
|
public osg::Drawable::DrawCallback
|
|
{
|
|
public:
|
|
DrawableDrawWithDepthShadowComparisonOffCallback( osg::Texture2D *pTex )
|
|
: _pTexture( pTex )
|
|
{
|
|
}
|
|
|
|
virtual void drawImplementation
|
|
( osg::RenderInfo & ri,const osg::Drawable* drawable ) const
|
|
{
|
|
ri.getState()->applyTextureAttribute( 0, _pTexture.get() );
|
|
|
|
// Turn off depth comparison mode
|
|
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE );
|
|
|
|
drawable->drawImplementation(ri);
|
|
|
|
// Turn it back on
|
|
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB,
|
|
GL_COMPARE_R_TO_TEXTURE_ARB );
|
|
}
|
|
|
|
osg::ref_ptr< osg::Texture2D > _pTexture;
|
|
};
|
|
|
|
void DebugShadowMap::ViewData::createDebugHUD( )
|
|
{
|
|
_cameraDebugHUD = new osg::Camera;
|
|
|
|
{ // Make sure default HUD layout makes sense
|
|
if( _hudSize[0] <= 0 ) _hudSize[0] = DEFAULT_DEBUG_HUD_SIZE_X;
|
|
if( _hudSize[1] <= 0 ) _hudSize[1] = DEFAULT_DEBUG_HUD_SIZE_Y;
|
|
|
|
if( _viewportSize[0] <= 0 ) _viewportSize[0] = _hudSize[0];
|
|
if( _viewportSize[1] <= 0 ) _viewportSize[1] = _hudSize[1];
|
|
|
|
if( _orthoSize[0] <= 0 ) _orthoSize[0] = _viewportSize[0];
|
|
if( _orthoSize[1] <= 0 ) _orthoSize[1] = _viewportSize[1];
|
|
}
|
|
|
|
{ // Initialize hud camera
|
|
osg::Camera * camera = _cameraDebugHUD.get();
|
|
camera->setComputeNearFarMode(osg::Camera::DO_NOT_COMPUTE_NEAR_FAR);
|
|
camera->setReferenceFrame(osg::Camera::ABSOLUTE_RF);
|
|
camera->setViewMatrix(osg::Matrix::identity());
|
|
camera->setViewport( _viewportOrigin[0], _viewportOrigin[1],
|
|
_viewportSize[0], _viewportSize[1] );
|
|
|
|
camera->setProjectionMatrixAsOrtho(
|
|
_orthoOrigin[0], _orthoOrigin[0] + _orthoSize[0],
|
|
_orthoOrigin[1], _orthoOrigin[1] + _orthoSize[1],
|
|
-10, 10 );
|
|
|
|
camera->setClearMask(GL_DEPTH_BUFFER_BIT);
|
|
camera->setRenderOrder(osg::Camera::POST_RENDER);
|
|
}
|
|
|
|
{ // Add geode and drawable with BaseClass display
|
|
// create geode to contain hud drawables
|
|
osg::Geode* geode = new osg::Geode;
|
|
_cameraDebugHUD->addChild(geode);
|
|
|
|
// finally create and attach hud geometry
|
|
osg::Geometry* geometry = osg::createTexturedQuadGeometry
|
|
( osg::Vec3(_hudOrigin[0],_hudOrigin[1],0),
|
|
osg::Vec3(_hudSize[0],0,0),
|
|
osg::Vec3(0,_hudSize[1],0) );
|
|
|
|
osg::StateSet* stateset = _cameraDebugHUD->getOrCreateStateSet();
|
|
stateset->setTextureAttributeAndModes(0,_texture.get(),osg::StateAttribute::ON );
|
|
stateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
|
|
// stateset->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
|
|
stateset->setAttributeAndModes
|
|
( new osg::Depth( osg::Depth::ALWAYS, 0, 1, false ) );
|
|
stateset->setMode(GL_BLEND,osg::StateAttribute::ON);
|
|
|
|
osg::Program* program = new osg::Program;
|
|
program->addShader( _depthColorFragmentShader.get() );
|
|
stateset->setAttribute( program );
|
|
stateset->addUniform( new osg::Uniform( "texture" , 0 ) );
|
|
|
|
geometry->setDrawCallback
|
|
( new DrawableDrawWithDepthShadowComparisonOffCallback( _texture.get() ) );
|
|
|
|
geode->addDrawable( geometry );
|
|
}
|
|
|
|
{ // Create transforms and geodes to manage polytope drawing
|
|
osg::StateSet * stateset = new osg::StateSet;
|
|
stateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
|
|
stateset->setTextureMode(0, GL_TEXTURE_2D, osg::StateAttribute::OFF);
|
|
stateset->setTextureMode(1, GL_TEXTURE_2D, osg::StateAttribute::OFF);
|
|
stateset->setMode(GL_BLEND, osg::StateAttribute::ON);
|
|
stateset->setMode(GL_CULL_FACE, osg::StateAttribute::OFF);
|
|
stateset->setAttribute( new osg::Program() );
|
|
stateset->setAttributeAndModes
|
|
( new osg::Depth( osg::Depth::LEQUAL, 0, 1, false ) );
|
|
|
|
for( int i = 0; i < 2; i++ ) {
|
|
_geode[i]->setStateSet( stateset );
|
|
_transform[i] = new osg::MatrixTransform;
|
|
_transform[i]->addChild( _geode[i].get() );
|
|
_transform[i]->setMatrix( osg::Matrix::identity() );
|
|
_transform[i]->setReferenceFrame( osg::MatrixTransform::ABSOLUTE_RF );
|
|
}
|
|
|
|
_transform[1]->setMatrix
|
|
( osg::Matrix::translate( 1, 1, 0 ) *
|
|
osg::Matrix::scale( 0.5, 0.5, 1 ) *
|
|
osg::Matrix::scale( _hudSize[0], _hudSize[1], 1 ) *
|
|
osg::Matrix::translate( _hudOrigin[0], _hudOrigin[1], 0 ) );
|
|
|
|
_cameraDebugHUD->addChild( _transform[1].get() );
|
|
}
|
|
}
|
|
|
|
osg::Vec3d DebugShadowMap::ViewData::computeShadowTexelToPixelError
|
|
( const osg::Matrix & mvpwView,
|
|
const osg::Matrix & mvpwShadow,
|
|
const osg::Vec3d & vWorld,
|
|
const osg::Vec3d & vDelta )
|
|
{
|
|
osg::Vec3d vS0 = mvpwShadow * vWorld;
|
|
osg::Vec3d vS1 = mvpwShadow * ( vWorld + vDelta );
|
|
|
|
osg::Vec3d vV0 = mvpwView * vWorld;
|
|
osg::Vec3d vV1 = mvpwView * ( vWorld + vDelta );
|
|
|
|
osg::Vec3d dV = vV1 - vV0;
|
|
osg::Vec3d dS = vS1 - vS0;
|
|
|
|
return osg::Vec3( dS[0] / dV[0], dS[1] / dV[1], dS[2] / dV[2] );
|
|
}
|
|
|
|
void DebugShadowMap::ViewData::displayShadowTexelToPixelErrors
|
|
( const osg::Camera* viewCamera,
|
|
const osg::Camera* shadowCamera,
|
|
const ConvexPolyhedron* hull )
|
|
{
|
|
osg::Matrix mvpwMain =
|
|
viewCamera->getViewMatrix() *
|
|
viewCamera->getProjectionMatrix() *
|
|
viewCamera->getViewport()->computeWindowMatrix();
|
|
|
|
osg::Matrix mvpwShadow =
|
|
shadowCamera->getViewMatrix() *
|
|
shadowCamera->getProjectionMatrix() *
|
|
shadowCamera->getViewport()->computeWindowMatrix();
|
|
|
|
osg::BoundingBox bb =
|
|
hull->computeBoundingBox( viewCamera->getViewMatrix() );
|
|
|
|
osg::Matrix m = viewCamera->getInverseViewMatrix();
|
|
|
|
osg::Vec3d vn = osg::Vec3d( 0, 0, bb._max[2] ) * m;
|
|
osg::Vec3d vf = osg::Vec3d( 0, 0, bb._min[2] ) * m;
|
|
osg::Vec3d vm = osg::Vec3d( 0, 0, ( bb._max[2] + bb._min[2] ) * 0.5 ) * m;
|
|
|
|
osg::Vec3d vne = computeShadowTexelToPixelError( mvpwMain, mvpwShadow, vn );
|
|
osg::Vec3d vfe = computeShadowTexelToPixelError( mvpwMain, mvpwShadow, vf );
|
|
osg::Vec3d vme = computeShadowTexelToPixelError( mvpwMain, mvpwShadow, vm );
|
|
|
|
std::cout << std::setprecision( 3 ) << " "
|
|
<< "ne=(" << vne[0] << "," << vne[1] << "," << vne[2] << ") "
|
|
<< "fe=(" << vfe[0] << "," << vfe[1] << "," << vfe[2] << ") "
|
|
<< "me=(" << vme[0] << "," << vme[1] << "," << vme[2] << ") "
|
|
<< "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
|
|
<< "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
|
|
<< "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
|
|
<< std::flush;
|
|
}
|
|
|