Hi Dario,
Code looks ok to me. Have not tried to build it though. I would check your
light source if its set and found by shadow technique. Shadow Technique may
use default viewer light instead. Also do a test with setDebugDraw( true )
and check if 'cyan on pink' depth texture is generated and changes with
moving camera. Compare it with osgshadow example ran with lispsm switch. If
depth texture is generated then it means light source is found and shadow
map computed. Then the only cuplrit may be applying this shadow map to
scene so I would check then if your visitor indeed does the right job and
check if there are no GLSL compilation / linking errors. (osg_notify_level
= debug).
You may also test your light and program applying visitor in osg shadow. If
it all works there then the models could be an issue ( do they have
protected programs set in their statesets ? ) ...
Cheers,
Wojtek Lewandowski
2012/7/24 Dario Minieri <para...@cheapnet.it>
> Hi,
>
> First, thanks for your reply. So, my basic test to "light the way" is the
> next:
>
> 1. I'm used the two shaders (vert and frag) for StandardShadowMap:
>
> frag:
>
>
> Code:
> uniform sampler2DShadow shadowTexture;
>
> float DynamicShadow( )
> {
> return shadow2DProj( shadowTexture, gl_TexCoord[1] ).r;
> }
>
> //following expressions are auto modified - do not change them:
> //gl_TexCoord[0] 0 - can be subsituted with other index
> float DynamicShadow( );
> varying vec4 colorAmbientEmissive;
> uniform sampler2D baseTexture;
>
> void main(void)
> {
> vec4 color = texture2D( baseTexture, gl_TexCoord[0].xy );
> color *= mix( colorAmbientEmissive, gl_Color, DynamicShadow() );
> float fog = clamp((gl_Fog.end - gl_FogFragCoord)*gl_Fog.scale, 0.,1.);
> color.rgb = mix( gl_Fog.color.rgb, color.rgb, fog );
> gl_FragColor = color;
> }
>
>
>
>
> vert:
>
>
> Code:
> void DynamicShadow( in vec4 ecPosition )
> {
> // generate coords for shadow mapping
> gl_TexCoord[1].s = dot( ecPosition, gl_EyePlaneS[1] );
> gl_TexCoord[1].t = dot( ecPosition, gl_EyePlaneT[1] );
> gl_TexCoord[1].p = dot( ecPosition, gl_EyePlaneR[1] );
> gl_TexCoord[1].q = dot( ecPosition, gl_EyePlaneQ[1] );
> }
>
> // following expressions are auto modified - do not change them:
> // gl_TexCoord[0] 0 - can be subsituted with other index
> // gl_TextureMatrix[0] 0 - can be subsituted with other index
> // gl_MultiTexCoord0 0 - can be subsituted with other index
> const int NumEnabledLights = 1;
> void DynamicShadow( in vec4 ecPosition );
> varying vec4 colorAmbientEmissive;
> void SpotLight(in int i,
> in vec3 eye,
> in vec3 ecPosition3,
> in vec3 normal,
> inout vec4 ambient,
> inout vec4 diffuse,
> inout vec4 specular)
> {
> float nDotVP; // normal . light direction
> float nDotHV; // normal . light half vector
> float pf; // power factor
> float spotDot; // cosine of angle between spotlight
> float spotAttenuation; // spotlight attenuation factor
> float attenuation; // computed attenuation factor
> float d; // distance from surface to light source
> vec3 VP; // direction from surface to light position
> vec3 halfVector; // direction of maximum highlights
>
> // Compute vector from surface to light position
> VP = vec3(gl_LightSource[i].position) - ecPosition3;
>
> // Compute distance between surface and light position
> d = length(VP);
>
> // Normalize the vector from surface to light position
> VP = normalize(VP);
>
> // Compute attenuation
> attenuation = 1.0 / (gl_LightSource[i].constantAttenuation +
> gl_LightSource[i].linearAttenuation * d +
> gl_LightSource[i].quadraticAttenuation *d*d);
>
> // See if point on surface is inside cone of illumination
> spotDot = dot(-VP, normalize(gl_LightSource[i].spotDirection));
>
> if (spotDot < gl_LightSource[i].spotCosCutoff)
> spotAttenuation = 0.0; // light adds no contribution
> else
> spotAttenuation = pow(spotDot, gl_LightSource[i].spotExponent);
>
> // Combine the spotlight and distance attenuation.
> attenuation *= spotAttenuation;
>
> halfVector = normalize(VP + eye);
>
> nDotVP = max(0.0, dot(normal, VP));
> nDotHV = max(0.0, dot(normal, halfVector));
>
> if (nDotVP == 0.0)
> pf = 0.0;
> else
> pf = pow(nDotHV, gl_FrontMaterial.shininess);
>
> ambient += gl_LightSource[i].ambient * attenuation;
> diffuse += gl_LightSource[i].diffuse * nDotVP * attenuation;
> specular += gl_LightSource[i].specular * pf * attenuation;
> }
>
> void PointLight(in int i,
> in vec3 eye,
> in vec3 ecPosition3,
> in vec3 normal,
> inout vec4 ambient,
> inout vec4 diffuse,
> inout vec4 specular)
> {
> float nDotVP; // normal . light direction
> float nDotHV; // normal . light half vector
> float pf; // power factor
> float attenuation; // computed attenuation factor
> float d; // distance from surface to light source
> vec3 VP; // direction from surface to light position
> vec3 halfVector; // direction of maximum highlights
>
> // Compute vector from surface to light position
> VP = vec3(gl_LightSource[i].position) - ecPosition3;
>
> // Compute distance between surface and light position
> d = length(VP);
>
> // Normalize the vector from surface to light position
> VP = normalize(VP);
>
> // Compute attenuation
> attenuation = 1.0 / (gl_LightSource[i].constantAttenuation +
> gl_LightSource[i].linearAttenuation * d +
> gl_LightSource[i].quadraticAttenuation * d*d);
>
> halfVector = normalize(VP + eye);
>
> nDotVP = max(0.0, dot(normal, VP));
> nDotHV = max(0.0, dot(normal, halfVector));
>
> if (nDotVP == 0.0)
> pf = 0.0;
> else
> pf = pow(nDotHV, gl_FrontMaterial.shininess);
>
> ambient += gl_LightSource[i].ambient * attenuation;
> diffuse += gl_LightSource[i].diffuse * nDotVP * attenuation;
> specular += gl_LightSource[i].specular * pf * attenuation;
> }
>
> void DirectionalLight(in int i,
> in vec3 normal,
> inout vec4 ambient,
> inout vec4 diffuse,
> inout vec4 specular)
> {
> float nDotVP; // normal . light direction
> float nDotHV; // normal . light half vector
> float pf; // power factor
>
> nDotVP = max(0.0, dot(normal,
> normalize(vec3(gl_LightSource[i].position))));
> nDotHV = max(0.0, dot(normal,
> vec3(gl_LightSource[i].halfVector)));
>
> if (nDotVP == 0.0)
> pf = 0.0;
> else
> pf = pow(nDotHV, gl_FrontMaterial.shininess);
>
> ambient += gl_LightSource[i].ambient;
> diffuse += gl_LightSource[i].diffuse * nDotVP;
> specular += gl_LightSource[i].specular * pf;
> }
>
> void main( )
> {
> // Transform vertex to clip space
> gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
> vec3 normal = normalize( gl_NormalMatrix * gl_Normal );
>
> vec4 ecPos = gl_ModelViewMatrix * gl_Vertex;
> float ecLen = length( ecPos );
> vec3 ecPosition3 = ecPos.xyz / ecPos.w;
>
> vec3 eye = vec3( 0.0, 0.0, 1.0 );
> //vec3 eye = -normalize(ecPosition3);
>
> DynamicShadow( ecPos );
>
> gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
>
> // Front Face lighting
>
> // Clear the light intensity accumulators
> vec4 amb = vec4(0.0);
> vec4 diff = vec4(0.0);
> vec4 spec = vec4(0.0);
>
> // Loop through enabled lights, compute contribution from each
> for (int i = 0; i < NumEnabledLights; i++)
> {
> if (gl_LightSource[i].position.w == 0.0)
> DirectionalLight(i, normal, amb, diff, spec);
> else if (gl_LightSource[i].spotCutoff == 180.0)
> PointLight(i, eye, ecPosition3, normal, amb, diff, spec);
> else
> SpotLight(i, eye, ecPosition3, normal, amb, diff, spec);
> }
>
> colorAmbientEmissive = gl_FrontLightModelProduct.sceneColor +
> amb * gl_FrontMaterial.ambient;
>
> gl_FrontColor = colorAmbientEmissive +
> diff * gl_FrontMaterial.diffuse;
>
> gl_FrontSecondaryColor = vec4(spec*gl_FrontMaterial.specular);
>
> gl_BackColor = gl_FrontColor;
> gl_BackSecondaryColor = gl_FrontSecondaryColor;
>
> gl_FogFragCoord = ecLen;
> }
>
>
>
> For now I'm not used any other GLSL code. So, I've created a simple
> application like this:
>
>
> Code:
> int main (int argc, char* argv[])
> {
> osg::ArgumentParser psr(&argc, argv);
>
> osgViewer::Viewer viewer(psr);
>
> std::string file = "path/to/model.osg";
> std::string terr = "path/to/terrain.osg";
>
> osg::ref_ptr<osgShadow::MinimalShadowMap> l_MinimalShadowMap;
> l_MinimalShadowMap = new osgShadow::LightSpacePerspectiveShadowMapCB();
> l_MinimalShadowMap->setMinLightMargin(10.0);
> l_MinimalShadowMap->setMaxFarPlane(1000.0);
> l_MinimalShadowMap->setTextureSize(osg::Vec2s(2048, 2048));
> l_MinimalShadowMap->setBaseTextureCoordIndex(0);
> l_MinimalShadowMap->setBaseTextureUnit(0);
> l_MinimalShadowMap->setShadowTextureCoordIndex(1);
> l_MinimalShadowMap->setShadowTextureUnit(1);
>
> osg::ref_ptr<osgShadow::ShadowedScene> root = new
> osgShadow::ShadowedScene;
> root->setReceivesShadowTraversalMask(RECEIVES_SHADOW_TRAVERSAL_MASK);
> root->setCastsShadowTraversalMask(CASTS_SHADOW_TRAVERSAL_MASK);
> root->setShadowTechnique(l_MinimalShadowMap.get());
>
> osg::Group* obj2 =
> dynamic_cast<osg::Group*>(osgDB::readNodeFile(terr));
> osg::Group* obj1 =
> dynamic_cast<osg::Group*>(osgDB::readNodeFile(file));
> if (obj1 == NULL || obj2 == NULL) {
> osg::notify(osg::FATAL) << "can't read file " << file << std::endl;
> return 1;
> }
>
> root->addChild(obj2);
> root->addChild(obj1);
>
> // add the state manipulator
> viewer.addEventHandler(new
> osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) );
> // add the thread model handler
> viewer.addEventHandler(new osgViewer::ThreadingHandler);
> // add the window size toggle handler
> viewer.addEventHandler(new osgViewer::WindowSizeHandler);
> // add the stats handler
> viewer.addEventHandler(new osgViewer::StatsHandler);
> // add the help handler
> viewer.addEventHandler(new
> osgViewer::HelpHandler(psr.getApplicationUsage()));
> // add the LOD Scale handler
> viewer.addEventHandler(new osgViewer::LODScaleHandler);
> // add the screen capture handler
> viewer.addEventHandler(new osgViewer::ScreenCaptureHandler);
>
> viewer.setSceneData(root);
>
> osg::LightSource* light = createLight(osg::Vec4(10,-10,5,0),
> osg::Vec4(1,1,1,1), osg::Vec4(1,1,1,1), osg::Vec4(1,1,1,1));
>
> osg::StateSet* planeStateset =
> static_cast<osg::Geode*>(obj1->getChild(0))->getOrCreateStateSet();
>
> light->setStateSetModes(*planeStateset, osg::StateAttribute::ON);
>
> osg::MatrixTransform * transform = new osg::MatrixTransform();
> transform->addChild(light);
> root->addChild(transform);
>
> osg::Shader * VertexShader = new osg::Shader( osg::Shader::VERTEX );
> osg::Shader * PixelShader = new osg::Shader( osg::Shader::FRAGMENT );
>
> osg::Program* prg = new osg::Program;
> //This visitor loads the shaders above and applies them to all nodes.
> PrepareNodeForShading visitor;
> visitor.setTheProgram(prg);
> visitor.setShaders(VertexShader, PixelShader);
> root.get()->accept(visitor);
>
> return viewer.run();
>
>
>
>
> The scene is black. I would expect the shadows. I have something terribly
> wrong. Some suggestions?
>
> Thank you!
>
> Cheers,
> Dario
>
> ------------------
> Read this topic online here:
> http://forum.openscenegraph.org/viewtopic.php?p=49010#49010
>
>
>
>
>
> _______________________________________________
> osg-users mailing list
> osg-users@lists.openscenegraph.org
> http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org
>
_______________________________________________
osg-users mailing list
osg-users@lists.openscenegraph.org
http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org
