Robert,
This is second attempt on Shadow Texgen precision. This time its not view
dependent but terrible tex coord jumps are eliminated. Effect was achieved by
using special modelview matrix for texgen placement. There is a chance you may
not like this idea, but it works for me.
Cheers,
Wojtek
----- Original Message -----
From: Wojciech Lewandowski
To: OpenSceneGraph Submissions
Sent: Thursday, February 28, 2008 3:58 PM
Subject: [osg-submissions] Fixes in osgShadow::ShadowMap
Hi Robert,
Attached is modified osgShadow::ShadowMap. I changed following things:
1:
Shadow map camera sets ABSOLUTE_RF_INHERIT_VIEWPOINT refernce frame.
2:
Light Direction by matrix multiplications replaced with transform3x3
multiplication.
3:
I made DebugingHUD functional by adding special draw callback. Former version
was simply drawing pale square.
4:
I was tempted to make 4 th change but decided to not do it. Instead I put it
whith #if VIEW_DEPNDENT_TEXGEN. If you decide you may let it go.
When objects are not centered at 0,0,0 coord but in some distant location
(for example at surface of earth ellipsoid) shadow texgen suffers from
inadequate precision of float matrices. I changed that by premultiplying Texgen
matrix (using OSG double matrices) with inverse modelview and applying it later
with ModelView identity matrix. This tweak may be appropriate for OverlayNode
texgen as well.
I left former version because I suspect that this change will make
osgShadow::ShadowMap view dependant. Currently texgen matrix remains the same
no matter what View displays it. With my change it wuld be different for each
view. This touches the subject of View Dependent Shadow Techniques that J-S
asked recently.
I suspect other Shadow techniques could also benefit from some of above
modifications. I have changed ShadowMap because I think I learned how it works.
I don't know that much about other techniques.
Regards,
Wojtek Lewandowski
------------------------------------------------------------------------------
_______________________________________________
osg-submissions mailing list
[email protected]
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
/* -*-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 <osgShadow/ShadowMap>
#include <osgShadow/ShadowedScene>
#include <osg/Notify>
#include <osg/ComputeBoundsVisitor>
#include <osg/PolygonOffset>
#include <osg/CullFace>
#include <osg/io_utils>
using namespace osgShadow;
#include <iostream>
//for debug
#include <osg/LightSource>
#include <osg/PolygonMode>
#include <osg/Geometry>
#include <osgDB/ReadFile>
#include <osgText/Text>
#define IMPROVE_TEXGEN_PRECISION 1
//////////////////////////////////////////////////////////////////
// fragment shader
//
static const char fragmentShaderSource_noBaseTexture[] =
"uniform sampler2DShadow osgShadow_shadowTexture; \n"
"uniform vec2 osgShadow_ambientBias; \n"
"\n"
"void main(void) \n"
"{ \n"
" gl_FragColor = gl_Color * (osgShadow_ambientBias.x + shadow2DProj(
osgShadow_shadowTexture, gl_TexCoord[0] ) * osgShadow_ambientBias.y); \n"
"}\n";
//////////////////////////////////////////////////////////////////
// fragment shader
//
static const char fragmentShaderSource_withBaseTexture[] =
"uniform sampler2D osgShadow_baseTexture; \n"
"uniform sampler2DShadow osgShadow_shadowTexture; \n"
"uniform vec2 osgShadow_ambientBias; \n"
"\n"
"void main(void) \n"
"{ \n"
" vec4 color = gl_Color * texture2D( osgShadow_baseTexture,
gl_TexCoord[0].xy ); \n"
" gl_FragColor = color * (osgShadow_ambientBias.x + shadow2DProj(
osgShadow_shadowTexture, gl_TexCoord[1] ) * osgShadow_ambientBias.y); \n"
"}\n";
//////////////////////////////////////////////////////////////////
// fragment shader
//
static const char fragmentShaderSource_debugHUD_texcoord[] =
"uniform sampler2D osgShadow_shadowTexture; \n"
" \n"
"void main(void) \n"
"{ \n"
" vec4 texCoord = gl_TexCoord[1].xyzw; \n"
" float value = texCoord.z / texCoord.w; \n"
" gl_FragColor = vec4( value, value, value, 1.0 ); \n"
"} \n";
static const char fragmentShaderSource_debugHUD[] =
"uniform sampler2D osgShadow_shadowTexture; \n"
" \n"
"void main(void) \n"
"{ \n"
" vec4 texResult = texture2D(osgShadow_shadowTexture, gl_TexCoord[0].st
); \n"
" float value = texResult.r; \n"
" gl_FragColor = vec4( value, value, value, 0.8 ); \n"
"} \n";
ShadowMap::ShadowMap():
_baseTextureUnit(0),
_shadowTextureUnit(1),
_ambientBias(0.5f,0.5f),
_textureSize(1024,1024)
{
}
ShadowMap::ShadowMap(const ShadowMap& copy, const osg::CopyOp& copyop):
ShadowTechnique(copy,copyop),
_baseTextureUnit(copy._baseTextureUnit),
_shadowTextureUnit(copy._shadowTextureUnit),
_ambientBias(copy._ambientBias),
_textureSize(copy._textureSize)
{
}
void ShadowMap::setTextureUnit(unsigned int unit)
{
_shadowTextureUnit = unit;
}
void ShadowMap::setAmbientBias(const osg::Vec2& ambientBias)
{
_ambientBias = ambientBias;
if (_ambientBiasUniform.valid()) _ambientBiasUniform->set(_ambientBias);
}
void ShadowMap::setTextureSize(const osg::Vec2s& textureSize)
{
_textureSize = textureSize;
dirty();
}
void ShadowMap::setLight(osg::Light* light)
{
_light = light;
}
void ShadowMap::setLight(osg::LightSource* ls)
{
_ls = ls;
_light = _ls->getLight();
}
void ShadowMap::createUniforms()
{
_uniformList.clear();
osg::Uniform* baseTextureSampler = new
osg::Uniform("osgShadow_baseTexture",(int)_baseTextureUnit);
_uniformList.push_back(baseTextureSampler);
osg::Uniform* shadowTextureSampler = new
osg::Uniform("osgShadow_shadowTexture",(int)_shadowTextureUnit);
_uniformList.push_back(shadowTextureSampler);
_ambientBiasUniform = new
osg::Uniform("osgShadow_ambientBias",_ambientBias);
_uniformList.push_back(_ambientBiasUniform.get());
}
void ShadowMap::createShaders()
{
// if we are not given shaders, use the default
if( _shaderList.empty() )
{
if (_shadowTextureUnit==0)
{
osg::Shader* fragment_shader = new
osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource_noBaseTexture);
_shaderList.push_back(fragment_shader);
}
else
{
osg::Shader* fragment_shader = new
osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource_withBaseTexture);
_shaderList.push_back(fragment_shader);
}
}
}
void ShadowMap::init()
{
if (!_shadowedScene) return;
_texture = new osg::Texture2D;
_texture->setTextureSize(_textureSize.x(), _textureSize.y());
_texture->setInternalFormat(GL_DEPTH_COMPONENT);
_texture->setShadowComparison(true);
_texture->setShadowTextureMode(osg::Texture2D::LUMINANCE);
_texture->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR);
_texture->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::LINEAR);
// the shadow comparison should fail if object is outside the texture
_texture->setWrap(osg::Texture2D::WRAP_S,osg::Texture2D::CLAMP_TO_BORDER);
_texture->setWrap(osg::Texture2D::WRAP_T,osg::Texture2D::CLAMP_TO_BORDER);
_texture->setBorderColor(osg::Vec4(1.0f,1.0f,1.0f,1.0f));
// set up the render to texture camera.
{
// create the camera
_camera = new osg::Camera;
_camera->setReferenceFrame(osg::Camera::ABSOLUTE_RF_INHERIT_VIEWPOINT);
_camera->setCullCallback(new CameraCullCallback(this));
_camera->setClearMask(GL_DEPTH_BUFFER_BIT);
//_camera->setClearMask(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
_camera->setClearColor(osg::Vec4(1.0f,1.0f,1.0f,1.0f));
_camera->setComputeNearFarMode(osg::Camera::DO_NOT_COMPUTE_NEAR_FAR);
// set viewport
_camera->setViewport(0,0,_textureSize.x(),_textureSize.y());
// set the camera to render before the main camera.
_camera->setRenderOrder(osg::Camera::PRE_RENDER);
// tell the camera to use OpenGL frame buffer object where supported.
_camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT);
//_camera->setRenderTargetImplementation(osg::Camera::SEPERATE_WINDOW);
// attach the texture and use it as the color buffer.
_camera->attach(osg::Camera::DEPTH_BUFFER, _texture.get());
osg::StateSet* stateset = _camera->getOrCreateStateSet();
#if 1
// cull front faces so that only backfaces contribute to depth map
osg::ref_ptr<osg::CullFace> cull_face = new osg::CullFace;
cull_face->setMode(osg::CullFace::FRONT);
stateset->setAttribute(cull_face.get(), osg::StateAttribute::ON |
osg::StateAttribute::OVERRIDE);
stateset->setMode(GL_CULL_FACE, osg::StateAttribute::ON |
osg::StateAttribute::OVERRIDE);
// negative polygonoffset - move the backface nearer to the eye point
so that backfaces
// shadow themselves
float factor = -1.0f;
float units = -1.0f;
osg::ref_ptr<osg::PolygonOffset> polygon_offset = new
osg::PolygonOffset;
polygon_offset->setFactor(factor);
polygon_offset->setUnits(units);
stateset->setAttribute(polygon_offset.get(), osg::StateAttribute::ON |
osg::StateAttribute::OVERRIDE);
stateset->setMode(GL_POLYGON_OFFSET_FILL, osg::StateAttribute::ON |
osg::StateAttribute::OVERRIDE);
#else
// disabling cull faces so that only front and backfaces contribute to
depth map
stateset->setMode(GL_CULL_FACE, osg::StateAttribute::OFF |
osg::StateAttribute::OVERRIDE);
// negative polygonoffset - move the backface nearer to the eye point
// so that front faces do not shadow themselves.
float factor = 1.0f;
float units = 1.0f;
osg::ref_ptr<osg::PolygonOffset> polygon_offset = new
osg::PolygonOffset;
polygon_offset->setFactor(factor);
polygon_offset->setUnits(units);
stateset->setAttribute(polygon_offset.get(), osg::StateAttribute::ON |
osg::StateAttribute::OVERRIDE);
stateset->setMode(GL_POLYGON_OFFSET_FILL, osg::StateAttribute::ON |
osg::StateAttribute::OVERRIDE);
#endif
}
{
_stateset = new osg::StateSet;
_stateset->setTextureAttributeAndModes(_shadowTextureUnit,_texture.get(),osg::StateAttribute::ON
| osg::StateAttribute::OVERRIDE);
_stateset->setTextureMode(_shadowTextureUnit,GL_TEXTURE_GEN_S,osg::StateAttribute::ON);
_stateset->setTextureMode(_shadowTextureUnit,GL_TEXTURE_GEN_T,osg::StateAttribute::ON);
_stateset->setTextureMode(_shadowTextureUnit,GL_TEXTURE_GEN_R,osg::StateAttribute::ON);
_stateset->setTextureMode(_shadowTextureUnit,GL_TEXTURE_GEN_Q,osg::StateAttribute::ON);
_texgen = new osg::TexGen;
// add Program, when empty of Shaders then we are using fixed
functionality
_program = new osg::Program;
_stateset->setAttribute(_program.get());
// create default shaders if needed
createShaders();
// add the shader list to the program
for(ShaderList::const_iterator itr=_shaderList.begin();
itr!=_shaderList.end();
++itr)
{
_program->addShader(itr->get());
}
// create own uniforms
createUniforms();
// add the uniform list to the stateset
for(UniformList::const_iterator itr=_uniformList.begin();
itr!=_uniformList.end();
++itr)
{
_stateset->addUniform(itr->get());
}
{
// fake texture for baseTexture, add a fake texture
// we support by default at least one texture layer
// without this fake texture we can not support
// textured and not textured scene
// TODO: at the moment the PSSM supports just one texture layer in
the GLSL shader, multitexture are
// not yet supported !
osg::Image* image = new osg::Image;
// allocate the image data, noPixels x 1 x 1 with 4 rgba floats -
equivilant to a Vec4!
int noPixels = 1;
image->allocateImage(noPixels,1,1,GL_RGBA,GL_FLOAT);
image->setInternalTextureFormat(GL_RGBA);
// fill in the image data.
osg::Vec4* dataPtr = (osg::Vec4*)image->data();
osg::Vec4 color(1,1,1,1);
*dataPtr = color;
// make fake texture
osg::Texture2D* fakeTex = new osg::Texture2D;
fakeTex->setWrap(osg::Texture2D::WRAP_S,osg::Texture2D::CLAMP_TO_EDGE);
fakeTex->setWrap(osg::Texture2D::WRAP_T,osg::Texture2D::CLAMP_TO_EDGE);
fakeTex->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR);
fakeTex->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::LINEAR);
fakeTex->setImage(image);
// add fake texture
_stateset->setTextureAttribute(_baseTextureUnit,fakeTex,osg::StateAttribute::ON);
_stateset->setTextureMode(_baseTextureUnit,GL_TEXTURE_1D,osg::StateAttribute::OFF);
_stateset->setTextureMode(_baseTextureUnit,GL_TEXTURE_2D,osg::StateAttribute::ON);
_stateset->setTextureMode(_baseTextureUnit,GL_TEXTURE_3D,osg::StateAttribute::OFF);
}
}
_dirty = false;
}
void ShadowMap::update(osg::NodeVisitor& nv)
{
_shadowedScene->osg::Group::traverse(nv);
}
void ShadowMap::cull(osgUtil::CullVisitor& cv)
{
// record the traversal mask on entry so we can reapply it later.
unsigned int traversalMask = cv.getTraversalMask();
osgUtil::RenderStage* orig_rs = cv.getRenderStage();
// do traversal of shadow receiving scene which does need to be decorated
by the shadow map
{
cv.pushStateSet(_stateset.get());
_shadowedScene->osg::Group::traverse(cv);
cv.popStateSet();
}
// need to compute view frustum for RTT camera.
// 1) get the light position
// 2) get the center and extents of the view frustum
const osg::Light* selectLight = 0;
osg::Vec4 lightpos;
osg::Vec3 lightDir;
//MR testing giving a specific light
osgUtil::PositionalStateContainer::AttrMatrixList& aml =
orig_rs->getPositionalStateContainer()->getAttrMatrixList();
for(osgUtil::PositionalStateContainer::AttrMatrixList::iterator itr =
aml.begin();
itr != aml.end();
++itr)
{
const osg::Light* light = dynamic_cast<const
osg::Light*>(itr->first.get());
if (light)
{
if( _light.valid()) {
if( _light.get() == light )
selectLight = light;
else
continue;
}
else
selectLight = light;
osg::RefMatrix* matrix = itr->second.get();
if (matrix)
{
lightpos = light->getPosition() * (*matrix);
lightDir = osg::Matrix::transform3x3( light->getDirection(),
*matrix );
}
else
{
lightpos = light->getPosition();
lightDir = light->getDirection();
}
}
}
osg::Matrix eyeToWorld;
eyeToWorld.invert(*cv.getModelViewMatrix());
lightpos = lightpos * eyeToWorld;
lightDir = osg::Matrix::transform3x3( lightDir, eyeToWorld );
lightDir.normalize();
if (selectLight)
{
// set to ambient on light to black so that the ambient bias uniform
can take it's affect
const_cast<osg::Light*>(selectLight)->setAmbient(osg::Vec4(0.0f,0.0f,0.0f,1.0f));
//std::cout<<"----- VxOSG::ShadowMap selectLight spot cutoff
"<<selectLight->getSpotCutoff()<<std::endl;
if(selectLight->getSpotCutoff() < 180.0f) // spotlight, then we don't
need the bounding box
{
osg::Vec3 position(lightpos.x(), lightpos.y(), lightpos.z());
float spotAngle = selectLight->getSpotCutoff();
_camera->setProjectionMatrixAsPerspective(spotAngle, 1.0, 0.1,
1000.0);
_camera->setViewMatrixAsLookAt(position,position+lightDir,osg::Vec3(0.0f,1.0f,0.0f));
}
else
{
// get the bounds of the model.
osg::ComputeBoundsVisitor
cbbv(osg::NodeVisitor::TRAVERSE_ACTIVE_CHILDREN);
cbbv.setTraversalMask(getShadowedScene()->getCastsShadowTraversalMask());
_shadowedScene->osg::Group::traverse(cbbv);
osg::BoundingBox bb = cbbv.getBoundingBox();
if (lightpos[3]!=0.0) // point light
{
osg::Vec3 position(lightpos.x(), lightpos.y(), lightpos.z());
float centerDistance = (position-bb.center()).length();
float znear = centerDistance-bb.radius();
float zfar = centerDistance+bb.radius();
float zNearRatio = 0.001f;
if (znear<zfar*zNearRatio) znear = zfar*zNearRatio;
float top = (bb.radius()/centerDistance)*znear;
float right = top;
_camera->setProjectionMatrixAsFrustum(-right,right,-top,top,znear,zfar);
_camera->setViewMatrixAsLookAt(position,bb.center(),osg::Vec3(0.0f,1.0f,0.0f));
}
else // directional light
{
// make an orthographic projection
osg::Vec3 lightDir(lightpos.x(), lightpos.y(), lightpos.z());
lightDir.normalize();
// set the position far away along the light direction
osg::Vec3 position = bb.center() + lightDir * bb.radius() * 2;
float centerDistance = (position-bb.center()).length();
float znear = centerDistance-bb.radius();
float zfar = centerDistance+bb.radius();
float zNearRatio = 0.001f;
if (znear<zfar*zNearRatio) znear = zfar*zNearRatio;
float top = bb.radius();
float right = top;
_camera->setProjectionMatrixAsOrtho(-right, right, -top, top,
znear, zfar);
_camera->setViewMatrixAsLookAt(position,bb.center(),osg::Vec3(0.0f,1.0f,0.0f));
}
}
cv.setTraversalMask( traversalMask &
getShadowedScene()->getCastsShadowTraversalMask() );
// do RTT camera traversal
_camera->accept(cv);
_texgen->setMode(osg::TexGen::EYE_LINEAR);
#if IMPROVE_TEXGEN_PRECISION
// compute the matrix which takes a vertex from local coords into tex
coords
// We actually use two matrices one used to define texgen
// and second that will be used as modelview when appling to OpenGL
_texgen->setPlanesFromMatrix( _camera->getProjectionMatrix() *
osg::Matrix::translate(1.0,1.0,1.0) *
osg::Matrix::scale(0.5f,0.5f,0.5f) );
// Place texgen with modelview which removes big offsets (making it
float friendly)
osg::RefMatrix * refMatrix = new osg::RefMatrix
( _camera->getInverseViewMatrix() * *cv.getModelViewMatrix() );
cv.getRenderStage()->getPositionalStateContainer()->
addPositionedTextureAttribute( _shadowTextureUnit, refMatrix,
_texgen.get() );
#else
// compute the matrix which takes a vertex from local coords into tex
coords
// will use this later to specify osg::TexGen..
osg::Matrix MVPT = _camera->getViewMatrix() *
_camera->getProjectionMatrix() *
osg::Matrix::translate(1.0,1.0,1.0) *
osg::Matrix::scale(0.5f,0.5f,0.5f);
_texgen->setPlanesFromMatrix(MVPT);
orig_rs->getPositionalStateContainer()->addPositionedTextureAttribute(_shadowTextureUnit,
cv.getModelViewMatrix(), _texgen.get());
#endif
} // if(selectLight)
// reapply the original traversal mask
cv.setTraversalMask( traversalMask );
}
void ShadowMap::cleanSceneGraph()
{
}
///////////////////// Debug Methods
////////////////////////////////////////////////////////////////////////////////
// Callback used by debugging hud to display Shadow Map in color buffer
// OSG does not allow to use the same GL Texture Id with different glTexParams.
// Callback simply turns shadow compare mode off via GL while rendering hud and
// restores it afterwards.
////////////////////////////////////////////////////////////////////////////////
class DrawableDrawWithDepthShadowComparisonOffCallback:
public osg::Drawable::DrawCallback
{
public:
//
DrawableDrawWithDepthShadowComparisonOffCallback
( osg::Texture2D * texture, unsigned stage = 0 )
: _texture( texture ), _stage( stage )
{
}
virtual void drawImplementation
( osg::RenderInfo & ri,const osg::Drawable* drawable ) const
{
if( _texture.valid() ) {
// make sure proper texture is currently applied
ri.getState()->applyTextureAttribute( _stage, _texture.get() );
// Turn off depth comparison mode
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB,
GL_NONE );
}
drawable->drawImplementation(ri);
if( _texture.valid() ) {
// Turn it back on
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB,
GL_COMPARE_R_TO_TEXTURE_ARB );
}
}
unsigned _stage;
osg::ref_ptr< osg::Texture2D > _texture;
};
////////////////////////////////////////////////////////////////////////////////
osg::ref_ptr<osg::Camera> ShadowMap::makeDebugHUD()
{
// Make sure we attach initialized texture to HUD
if( !_texture.valid() ) init();
osg::ref_ptr<osg::Camera> camera = new osg::Camera;
osg::Vec2 size(1280, 1024);
// set the projection matrix
camera->setProjectionMatrix(osg::Matrix::ortho2D(0,size.x(),0,size.y()));
// set the view matrix
camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
camera->setViewMatrix(osg::Matrix::identity());
// only clear the depth buffer
camera->setClearMask(GL_DEPTH_BUFFER_BIT);
camera->setClearColor(osg::Vec4(0.2f, 0.3f, 0.5f, 0.2f));
//camera->setClearMask(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
// draw subgraph after main camera view.
camera->setRenderOrder(osg::Camera::POST_RENDER);
// we don't want the camera to grab event focus from the viewers main
camera(s).
camera->setAllowEventFocus(false);
osg::Geode* geode = new osg::Geode;
osg::Vec3 position(10.0f,size.y()-100.0f,0.0f);
osg::Vec3 delta(0.0f,-120.0f,0.0f);
float length = 300.0f;
// turn the text off to avoid linking with osgText
#if 0
std::string timesFont("fonts/arial.ttf");
{
osgText::Text* text = new osgText::Text;
geode->addDrawable( text );
text->setFont(timesFont);
text->setPosition(position);
text->setText("Shadow Map HUD");
position += delta;
}
#endif
osg::Vec3 widthVec(length, 0.0f, 0.0f);
osg::Vec3 depthVec(0.0f,length, 0.0f);
osg::Vec3 centerBase( 10.0f + length/2, size.y()-length/2, 0.0f);
centerBase += delta;
osg::Geometry *geometry = osg::createTexturedQuadGeometry
( centerBase-widthVec*0.5f-depthVec*0.5f, widthVec, depthVec );
geode->addDrawable( geometry );
geometry->setDrawCallback
( new DrawableDrawWithDepthShadowComparisonOffCallback( _texture.get()
) );
osg::StateSet* stateset = geode->getOrCreateStateSet();
stateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
stateset->setMode(GL_BLEND,osg::StateAttribute::ON);
//stateset->setAttribute(new
osg::PolygonOffset(1.0f,1.0f),osg::StateAttribute::ON);
stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
// test with regular texture
//stateset->setTextureAttributeAndModes(0, new
osg::Texture2D(osgDB::readImageFile("Images/lz.rgb")));
stateset->setTextureAttributeAndModes(0,_texture.get(),osg::StateAttribute::ON);
//test to check the texture coordinates generated during shadow pass
#if 0
stateset->setTextureMode(_shadowTextureUnit,GL_TEXTURE_GEN_S,osg::StateAttribute::ON);
stateset->setTextureMode(_shadowTextureUnit,GL_TEXTURE_GEN_T,osg::StateAttribute::ON);
stateset->setTextureMode(_shadowTextureUnit,GL_TEXTURE_GEN_R,osg::StateAttribute::ON);
stateset->setTextureMode(_shadowTextureUnit,GL_TEXTURE_GEN_Q,osg::StateAttribute::ON);
// create TexGen node
osg::ref_ptr<osg::TexGenNode> texGenNode = new osg::TexGenNode;
texGenNode->setTextureUnit(_shadowTextureUnit);
texGenNode->setTexGen(_texgen.get());
camera->addChild(texGenNode.get());
#endif
//shader for correct display
osg::ref_ptr<osg::Program> program = new osg::Program;
stateset->setAttribute(program.get());
osg::Shader* fragment_shader = new osg::Shader(osg::Shader::FRAGMENT,
fragmentShaderSource_debugHUD);
program->addShader(fragment_shader);
camera->addChild(geode);
return camera;
}
//////////////////////// End Debug Section
_______________________________________________
osg-submissions mailing list
[email protected]
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
