Hi Guys,
here is the code.
Nick
http://www.linkedin.com/in/tnick
Sent from Devlet, Ankara, Turkey
On Thu, Jan 14, 2010 at 11:42 PM, Wojciech Lewandowski <
[email protected]> wrote:
> Hi Nick,
>
> Post the troublesome code and elaborate a bit more about the problem. If
> its really a minute or two I am sure someone will be able to help.
>
> Wojtek Lewandowski
>
> *From:* Trajce Nikolov <[email protected]>
> *Sent:* Thursday, January 14, 2010 8:58 PM
> *To:* OpenSceneGraph Users <[email protected]>
> *Subject:* [osg-users] light lobes and shadow maps
>
> Hi community,
>
> I have some shader that does some lighting in the scene. Now studying
> osgShadow and the techniques. I want to a shadow map technique to disable
> the lightening of the scene behind obstacles. I have some code done, but not
> working. I need some help, someone experienced with GLSL to spend a minute
> or to to have a look and if possible to spot the problem. Anyone?
>
> Thanks a lot
>
> Nick
>
> http://www.linkedin.com/in/tnick
> Sent from Izmit, 41, Turkey
>
> ------------------------------
>
> _______________________________________________
> osg-users mailing list
> [email protected]
> http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org
>
>
> _______________________________________________
> osg-users mailing list
> [email protected]
> http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org
>
>
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
*
* This application is open source and may be redistributed and/or modified
* freely and without restriction, both in commericial and non commericial
applications,
* as long as this copyright notice is maintained.
*
* This application 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.
*/
#include <osgDB/ReadFile>
#include <osgDB/WriteFile>
#include <osgUtil/Optimizer>
#include <osg/CoordinateSystemNode>
#include <osg/Switch>
#include <osg/LightSource>
#include <osgText/Text>
#include <osgViewer/Viewer>
#include <osgViewer/CompositeViewer>
#include <osgViewer/ViewerEventHandlers>
#include <osgGA/TrackballManipulator>
#include <osgGA/FlightManipulator>
#include <osgGA/DriveManipulator>
#include <osgGA/KeySwitchMatrixManipulator>
#include <osgGA/StateSetManipulator>
#include <osgGA/AnimationPathManipulator>
#include <osgGA/TerrainManipulator>
#include <osgSim/OverlayNode>
#include <osg/Geode>
#include <osgText/Text3D>
#include <osg/MatrixTransform>
#include <osg/ShapeDrawable>
#include <osg/TexGen>
#include <osg/TexGenNode>
#include <iostream>
#include <sstream>
#include <osg/Geometry>
#include <osg/Geode>
#include <osg/LightSource>
#include <osg/LightModel>
#include <osg/Program>
#include <osg/ImageStream>
#include <osg/TextureRectangle>
#include <osg/TexMat>
#include <osg/BlendFunc>
#include <osg/AlphaFunc>
#include <osg/Material>
#include <osgUtil/SmoothingVisitor>
#include <osg/ShapeDrawable>
#include <osg/PositionAttitudeTransform>
#include <osg/TextureRectangle>
#if 1
osg::Matrixd createTransformMatrix(double x, double y, double z, double h,
double p, double r)
{
osg::Matrixd mxR;
mxR.makeRotate(osg::DegreesToRadians(r),osg::Vec3(0,1,0));
osg::Matrixd mxP;
mxP.makeRotate(osg::DegreesToRadians(p),osg::Vec3(1,0,0));
osg::Matrixd mxH;
mxH.makeRotate(osg::DegreesToRadians(h),osg::Vec3(0,0,1));
osg::Matrixd mxT;
mxT.makeTranslate(osg::Vec3(x,y,z));
return (mxR*mxP*mxH*mxT);
}
osg::Node* makeFrustumFromCamera( osg::Camera* camera )
{
// Projection and ModelView matrices
osg::Matrixd proj;
osg::Matrixd mv;
if (camera)
{
proj = camera->getProjectionMatrix();
mv = camera->getViewMatrix();
}
else
{
// Create some kind of reasonable default Projection matrix.
proj.makePerspective( 30., 1., 1., 10. );
// leave mv as identity
}
// Get near and far from the Projection matrix.
const double near = proj(3,2) / (proj(2,2)-1.0);
const double far = proj(3,2) / (1.0+proj(2,2));
// Get the sides of the near plane.
const double nLeft = near * (proj(2,0)-1.0) / proj(0,0);
const double nRight = near * (1.0+proj(2,0)) / proj(0,0);
const double nTop = near * (1.0+proj(2,1)) / proj(1,1);
const double nBottom = near * (proj(2,1)-1.0) / proj(1,1);
// Get the sides of the far plane.
const double fLeft = far * (proj(2,0)-1.0) / proj(0,0);
const double fRight = far * (1.0+proj(2,0)) / proj(0,0);
const double fTop = far * (1.0+proj(2,1)) / proj(1,1);
const double fBottom = far * (proj(2,1)-1.0) / proj(1,1);
// Our vertex array needs only 9 vertices: The origin, and the
// eight corners of the near and far planes.
osg::Vec3Array* v = new osg::Vec3Array;
v->resize( 9 );
(*v)[0].set( 0., 0., 0. );
(*v)[1].set( nLeft, nBottom, -near );
(*v)[2].set( nRight, nBottom, -near );
(*v)[3].set( nRight, nTop, -near );
(*v)[4].set( nLeft, nTop, -near );
(*v)[5].set( fLeft, fBottom, -far );
(*v)[6].set( fRight, fBottom, -far );
(*v)[7].set( fRight, fTop, -far );
(*v)[8].set( fLeft, fTop, -far );
osg::Geometry* geom = new osg::Geometry;
geom->setUseDisplayList( false );
geom->setVertexArray( v );
osg::Vec4Array* c = new osg::Vec4Array;
c->push_back( osg::Vec4( 1., 1., 1., 1. ) );
geom->setColorArray( c );
geom->setColorBinding( osg::Geometry::BIND_OVERALL );
GLushort idxLines[8] = {
0, 5, 0, 6, 0, 7, 0, 8 };
GLushort idxLoops0[4] = {
1, 2, 3, 4 };
GLushort idxLoops1[4] = {
5, 6, 7, 8 };
geom->addPrimitiveSet( new osg::DrawElementsUShort(
osg::PrimitiveSet::LINES, 8, idxLines ) );
geom->addPrimitiveSet( new osg::DrawElementsUShort(
osg::PrimitiveSet::LINE_LOOP, 4, idxLoops0 ) );
geom->addPrimitiveSet( new osg::DrawElementsUShort(
osg::PrimitiveSet::LINE_LOOP, 4, idxLoops1 ) );
osg::Geode* geode = new osg::Geode;
geode->addDrawable( geom );
geode->getOrCreateStateSet()->setMode( GL_LIGHTING,
osg::StateAttribute::OFF | osg::StateAttribute::PROTECTED );
// Create parent MatrixTransform to transform the view volume by
// the inverse ModelView matrix.
osg::MatrixTransform* mt = new osg::MatrixTransform;
mt->setMatrix( osg::Matrixd::inverse( mv ) );
mt->addChild( geode );
return mt;
}
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 );
}
}
osg::ref_ptr< osg::Texture2D > _texture;
unsigned _stage;
};
osg::Node* createScene(osg::ArgumentParser& arguments, osgViewer::Viewer*
viewer = 0)
{
osg::Group* group = new osg::Group;
osg::Group* scene = new osg::Group;
scene->addChild(group);
osg::MatrixTransform* mx = 0;
osg::MatrixTransform* mx2 = 0;
osg::Geometry* scenegeometry = 0;
osg::Geode* geode = new osg::Geode;
group->addChild(geode);
// "TERRAIN"
{
mx2 = new osg::MatrixTransform;
mx2->setMatrix(osg::Matrix::scale(osg::Vec3(35,35,35)));
group->addChild(mx2);
osg::Geode* geode = new osg::Geode;
mx2->addChild(geode);
scenegeometry = new osg::Geometry;
geode->addDrawable(scenegeometry);
osg::Vec3Array* vxs = new osg::Vec3Array;
vxs->push_back( osg::Vec3(-0.5,-0.5,0) );
vxs->push_back( osg::Vec3(0.5,-0.5,0) );
vxs->push_back( osg::Vec3(0.5,0.5,0) );
vxs->push_back( osg::Vec3(-0.5,0.5,0) );
scenegeometry->setVertexArray( vxs );
osg::Vec2Array* uvs = new osg::Vec2Array;
uvs->push_back( osg::Vec2(0,0) );
uvs->push_back( osg::Vec2(1,0) );
uvs->push_back( osg::Vec2(1,1) );
uvs->push_back( osg::Vec2(0,1) );
scenegeometry->setTexCoordArray(0,uvs);
for (unsigned int i=0; i<10; ++i)
{
double pos = -0.5+(0.1*i);
double w = 0.05;
vxs->push_back( osg::Vec3(pos,0.0,-0.1) );
vxs->push_back( osg::Vec3(pos+w,0.0,-0.1) );
vxs->push_back( osg::Vec3(pos+w,0.0,0.1) );
vxs->push_back( osg::Vec3(pos,0.0,0.1) );
uvs->push_back( osg::Vec2(0,0) );
uvs->push_back( osg::Vec2(1,0) );
uvs->push_back( osg::Vec2(1,1) );
uvs->push_back( osg::Vec2(0,1) );
}
osg::Image* image = osgDB::readImageFile("Images/lz.rgb");
if (image)
{
osg::Texture2D* texture = new osg::Texture2D;
texture->setImage(image);
scenegeometry->getOrCreateStateSet()->setTextureAttributeAndModes(0,texture,osg::StateAttribute::ON);
}
scenegeometry->addPrimitiveSet( new
osg::DrawArrays(osg::PrimitiveSet::QUADS,0,vxs->size()) );
osg::Material* mt = new osg::Material;
mt->setAmbient(osg::Material::FRONT_AND_BACK,osg::Vec4(0.3,0.3,0.3,1));
mt->setDiffuse(osg::Material::FRONT_AND_BACK,osg::Vec4(0.9,0.5,0.5,1));
mt->setSpecular(osg::Material::FRONT_AND_BACK,osg::Vec4(0.6,0.6,0.6,1));
mt->setShininess(osg::Material::FRONT_AND_BACK,60);
scenegeometry->getOrCreateStateSet()->setAttributeAndModes(mt,osg::StateAttribute::ON);
}
// "LIGHT SOURCE"
{
for (unsigned int i=1; i<=1; ++i)
{
osg::LightSource* light = new osg::LightSource;
light->getLight()->setLightNum(i);
light->getLight()->setAmbient(osg::Vec4(0,0,0,1));
light->getLight()->setDiffuse(osg::Vec4(0,1,0,1));
light->getLight()->setSpecular(osg::Vec4(1,1,1,1));
light->getLight()->setConstantAttenuation(0.01);
light->getLight()->setSpotCutoff(20);
light->setStateSetModes(*group->getOrCreateStateSet(),osg::StateAttribute::ON);
light->getLight()->setDirection(osg::Vec3(0,1,0));
light->getLight()->setPosition(osg::Vec4(0,0,0,1));
mx = new osg::MatrixTransform;
mx->setMatrix(createTransformMatrix(15-i*2.5,-4,3,0,-45,0));
mx->addChild(light);
osg::Geode* geode = new osg::Geode;
mx->addChild(geode);
float radius = 0.2f;
osg::TessellationHints* hints = new
osg::TessellationHints;
hints->setDetailRatio(0.5f);
geode->addDrawable(new osg::ShapeDrawable(new
osg::Sphere(osg::Vec3(0.0f,0.0f,0.0f),radius),hints));
group->addChild(mx);
}
}
// SCENE LIGHTING
{
const char* microshaderVertSource =
"varying vec3 normal, eyeVec;\n"
"varying vec3 lightDirs[8];\n"
"varying vec4 projShadow;\n"
" uniform mat4 LightModelViewProjectionMatrix;\n"
"\n"
"void main()\n"
"{ \n"
" gl_TexCoord[0] = gl_MultiTexCoord0;\n"
" normal = gl_NormalMatrix * gl_Normal;\n"
" \n"
" vec3 vVertex = vec3(gl_ModelViewMatrix *
gl_Vertex);\n"
" lightDirs[0] =
vec3(gl_LightSource[0].position.xyz - vVertex);\n"
" lightDirs[1] =
vec3(gl_LightSource[1].position.xyz - vVertex);\n"
" lightDirs[2] =
vec3(gl_LightSource[2].position.xyz - vVertex);\n"
" lightDirs[3] =
vec3(gl_LightSource[3].position.xyz - vVertex);\n"
" lightDirs[4] =
vec3(gl_LightSource[4].position.xyz - vVertex);\n"
" lightDirs[5] =
vec3(gl_LightSource[5].position.xyz - vVertex);\n"
" lightDirs[6] =
vec3(gl_LightSource[6].position.xyz - vVertex);\n"
" lightDirs[7] =
vec3(gl_LightSource[7].position.xyz - vVertex);\n"
" eyeVec = -vVertex;\n"
" projShadow = LightModelViewProjectionMatrix *
gl_Vertex;\n"
"\n"
" gl_Position = ftransform(); \n"
"}\n";
const char* microshaderFragSource =
"uniform sampler2D color_texture;\n"
"uniform sampler2DShadow shadow_texture;\n"
"varying vec4 projShadow;\n"
"\n"
"uniform bool fogActive;\n"
"\n"
"const int NumEnabledLights = 1; \n"
"\n"
"varying vec3 normal, eyeVec;\n"
"varying vec3 lightDirs[8];\n"
"\n"
"const float cos_outer_cone_angle = 0.8; // 36
degrees\n"
"\n"
"void main (void)\n"
"{\n"
"vec4 combined_color = vec4(0.0);\n"
"for (int i = 1; i < 1+NumEnabledLights; i++)\n"
"{ \n"
" vec4 final_color =\n"
" (gl_FrontLightModelProduct.sceneColor *
gl_FrontMaterial.ambient) +\n"
" (gl_LightSource[i].ambient *
gl_FrontMaterial.ambient);\n"
"\n"
" float distSqr =
dot(lightDirs[i],lightDirs[i]);\n"
" float invRadius =
gl_LightSource[i].constantAttenuation;\n"
" float att = clamp(1.0-invRadius *
sqrt(distSqr), 0.0, 1.0);\n"
" vec3 L = lightDirs[i] * inversesqrt(distSqr);\n"
" vec3 D =
normalize(gl_LightSource[i].spotDirection);\n"
"\n"
" float cos_cur_angle = dot(-L, D);\n"
"\n"
" float cos_inner_cone_angle =
gl_LightSource[i].spotCosCutoff;\n"
"\n"
" float cos_inner_minus_outer_angle = \n"
" cos_inner_cone_angle -
cos_outer_cone_angle;\n"
" \n"
" float spot = 0.0;\n"
" spot = clamp((cos_cur_angle -
cos_outer_cone_angle) / \n"
" cos_inner_minus_outer_angle, 0.0,
1.0);\n"
"\n"
" vec3 N = normalize(normal);\n"
"\n"
" float lambertTerm = max( dot(N,L), 0.0);\n"
" if(lambertTerm > 0.0)\n"
" {\n"
" final_color +=
gl_LightSource[i].diffuse *\n"
" gl_FrontMaterial.diffuse *\n"
" lambertTerm * spot * att;\n"
"\n"
" vec3 E = normalize(eyeVec);\n"
" vec3 R = reflect(-L, N);\n"
"\n"
" float specular = pow( max(dot(R, E),
0.0),\n"
" gl_FrontMaterial.shininess );\n"
"\n"
" final_color +=
gl_LightSource[i].specular *\n"
" gl_FrontMaterial.specular *\n"
" specular * spot * att;\n"
" }\n"
" vec4 clr = final_color * shadow2DProj(
shadow_texture, projShadow ).r;\n"
" combined_color += clr;\n"
"}\n"
" {\n"
" vec4 final_color = \n"
" (gl_FrontLightModelProduct.sceneColor *
gl_FrontMaterial.ambient) + \n"
" (gl_LightSource[0].ambient *
gl_FrontMaterial.ambient);\n"
"\n"
" vec3 N = normalize(normal);\n"
" vec3 L = normalize(lightDirs[0]);\n"
"\n"
" float lambertTerm = dot(N,L);\n"
"\n"
" if(lambertTerm > 0.0)\n"
" {\n"
" final_color +=
gl_LightSource[0].diffuse * \n"
" gl_FrontMaterial.diffuse
* \n"
" lambertTerm;
\n"
"\n"
" vec3 E = normalize(eyeVec);\n"
" vec3 R = reflect(-L, N);\n"
" float specular = pow(
max(dot(R, E), 0.0), \n"
"
gl_FrontMaterial.shininess );\n"
" final_color +=
gl_LightSource[0].specular * \n"
"
gl_FrontMaterial.specular * \n"
" specular;
\n"
" }\n"
" combined_color += final_color;\n"
" }\n"
" vec4 preFogColor = texture2D(color_texture,
gl_TexCoord[0].st) * combined_color;\n"
" if (fogActive)\n"
" {\n"
" const float LOG2 = 1.442695;\n"
" float z = gl_FragCoord.z /
gl_FragCoord.w;\n"
" float fogFactor = exp2( -gl_Fog.density
* \n"
" gl_Fog.density * \n"
" z * \n"
" z * \n"
" LOG2 );\n"
" fogFactor = clamp(fogFactor, 0.0,
1.0);\n"
" gl_FragColor = mix(gl_Fog.color,
preFogColor, fogFactor );"
" }\n"
" else gl_FragColor = preFogColor;\n"
"}\n";
osg::Program* program = new osg::Program;
program->setName( "microshader" );
program->addShader( new osg::Shader( osg::Shader::VERTEX,
microshaderVertSource ) );
program->addShader( new osg::Shader( osg::Shader::FRAGMENT,
microshaderFragSource ) );
group->getOrCreateStateSet()->setAttributeAndModes( program,
osg::StateAttribute::ON );
group->getOrCreateStateSet()->addUniform( new
osg::Uniform("fogActive",false) );
group->getOrCreateStateSet()->addUniform( new
osg::Uniform("color_texture",0) );
group->getOrCreateStateSet()->addUniform( new
osg::Uniform("shadow_texture",1) );
}
// HUD
{
osg::Camera* camera = new osg::Camera;
scene->addChild(camera);
double width = 1280;
double height = 1024;
camera->setProjectionMatrix(osg::Matrix::ortho2D(0,width,0,height));
camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
camera->setViewMatrix(osg::Matrix::identity());
camera->setClearMask(GL_DEPTH_BUFFER_BIT);
camera->setRenderOrder(osg::Camera::POST_RENDER);
camera->setAllowEventFocus(false);
osg::Geode* geode = new osg::Geode;
camera->addChild(geode);
camera->getOrCreateStateSet()->setMode(GL_LIGHTING,osg::StateAttribute::OFF|osg::StateAttribute::OVERRIDE|osg::StateAttribute::PROTECTED);
double offset = 50;
double wf = 512;
double hf = 512;
osg::Geometry *geometry =
osg::createTexturedQuadGeometry(osg::Vec3(offset,2*offset,-0.1),osg::Vec3(wf,0,0),osg::Vec3(0,hf,0));
geode->addDrawable(geometry);
osg::Shader* shader = new osg::Shader( osg::Shader::FRAGMENT,
#if 0
"uniform sampler2D texture; \n"
" \n"
"void main(void) \n"
"{ \n"
" vec4 texResult = texture2D(texture,
gl_TexCoord[1].st ); \n"
" float value = texResult.r; \n"
" gl_FragColor = vec4( value, value, value, 0.8 ); \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"
"
\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
);
osg::Program* program = new osg::Program;
program->addShader( shader );
geometry->getOrCreateStateSet()->setAttribute( program );
geometry->getOrCreateStateSet()->addUniform( new osg::Uniform(
"texture" , 0 ) );
osg::Texture2D* dbgDepthTexture = new osg::Texture2D;
dbgDepthTexture->setTextureSize(512, 512);
dbgDepthTexture->setInternalFormat(GL_DEPTH_COMPONENT);
dbgDepthTexture->setShadowTextureMode(osg::Texture2D::LUMINANCE);
dbgDepthTexture->setShadowComparison(true);
dbgDepthTexture->setShadowCompareFunc(osg::Texture::LEQUAL);
dbgDepthTexture->setWrap(osg::Texture::WRAP_S,
osg::Texture::CLAMP_TO_EDGE);
dbgDepthTexture->setWrap(osg::Texture::WRAP_T,
osg::Texture::CLAMP_TO_EDGE);
dbgDepthTexture->setWrap(osg::Texture::WRAP_R,
osg::Texture::CLAMP_TO_EDGE);
dbgDepthTexture->setFilter(osg::Texture::MIN_FILTER,osg::Texture::LINEAR);
dbgDepthTexture->setFilter(osg::Texture::MAG_FILTER,osg::Texture::LINEAR);
geometry->getOrCreateStateSet()->setTextureAttributeAndModes(0,dbgDepthTexture,osg::StateAttribute::ON);
scenegeometry->getOrCreateStateSet()->setTextureAttributeAndModes(1,dbgDepthTexture,osg::StateAttribute::ON);
geometry->setDrawCallback( new
DrawableDrawWithDepthShadowComparisonOffCallback(dbgDepthTexture) );
// LIGHT CAMERA
{
osg::Camera* camera = new osg::Camera;
camera->setReferenceFrame(osg::Camera::ABSOLUTE_RF);
camera->setProjectionMatrixAsPerspective(45, 1, 0.001,
10 );
camera->setViewport(0,0,512,512);
camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT);
camera->setClearColor(osg::Vec4(1.f,1.f,1.f,1.0f));
camera->setClearMask(GL_DEPTH_BUFFER_BIT);
camera->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR);
camera->addChild(mx2);
camera->setRenderOrder(osg::Camera::PRE_RENDER);
camera->attach(osg::Camera::DEPTH_BUFFER,dbgDepthTexture);
camera->setCullingActive(true);
{
osg::Matrixd mxd = mx->getMatrix();
osg::Quat q = mxd.getRotate();
osg::Vec3 t = mxd.getTrans();
osg::Quat fq;
fq.makeRotate(osg::Vec3(0,0,-1),osg::Vec3(0,1,0));
osg::Matrixd mR;
mR.makeRotate(q);
osg::Matrixd mT;
mT.makeTranslate(t);
osg::Matrixd mF;
mF.makeRotate(fq);
osg::Matrixd m;
m = mF * mR * mT;
camera->setViewMatrix(osg::Matrixd::inverse(m));
}
osg::Matrixd lmvpm =
camera->getViewMatrix() *
camera->getProjectionMatrix();
group->getOrCreateStateSet()->addUniform( new
osg::Uniform("LightModelViewProjectionMatrix",lmvpm) );
scene->addChild(camera);
scene->addChild( makeFrustumFromCamera(camera) );
}
}
return scene;
}
#endif
void setupViewer(osgViewer::Viewer* viewer, osg::ArgumentParser& arguments)
{
// set up the camera manipulators.
{
osg::ref_ptr<osgGA::KeySwitchMatrixManipulator> keyswitchManipulator =
new osgGA::KeySwitchMatrixManipulator;
keyswitchManipulator->addMatrixManipulator( '1', "Trackball", new
osgGA::TrackballManipulator() );
keyswitchManipulator->addMatrixManipulator( '2', "Flight", new
osgGA::FlightManipulator() );
keyswitchManipulator->addMatrixManipulator( '3', "Drive", new
osgGA::DriveManipulator() );
keyswitchManipulator->addMatrixManipulator( '4', "Terrain", new
osgGA::TerrainManipulator() );
viewer->setCameraManipulator( keyswitchManipulator.get() );
}
// 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(arguments.getApplicationUsage()));
// add the record camera path handler
viewer->addEventHandler(new osgViewer::RecordCameraPathHandler);
// add the LOD Scale handler
viewer->addEventHandler(new osgViewer::LODScaleHandler);
// add the screen capture handler
viewer->addEventHandler(new osgViewer::ScreenCaptureHandler);
}
int main(int argc, char** argv)
{
// use an ArgumentParser object to manage the program arguments.
osg::ArgumentParser arguments(&argc,argv);
arguments.getApplicationUsage()->setApplicationName(arguments.getApplicationName());
arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+"
is the standard OpenSceneGraph example which loads and visualises 3d models.");
arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName()+"
[options] filename ...");
arguments.getApplicationUsage()->addCommandLineOption("--image
<filename>","Load an image and render it on a quad");
arguments.getApplicationUsage()->addCommandLineOption("--dem
<filename>","Load an image/DEM and render it on a HeightField");
arguments.getApplicationUsage()->addCommandLineOption("--login <url>
<username> <password>","Provide authentication information for http file
access.");
osg::ref_ptr<osgViewer::Viewer> viewer = new
osgViewer::Viewer(arguments);
viewer->getLight()->setAmbient(osg::Vec4(0.2,0.2,0.2,1));
viewer->getLight()->setDiffuse(osg::Vec4(0.7,0.5,0.5,1));
unsigned int helpType = 0;
if ((helpType = arguments.readHelpType()))
{
arguments.getApplicationUsage()->write(std::cout, helpType);
return 1;
}
// report any errors if they have occurred when parsing the program
arguments.
if (arguments.errors())
{
arguments.writeErrorMessages(std::cout);
return 1;
}
#if 0
if (arguments.argc()<=1)
{
arguments.getApplicationUsage()->write(std::cout,osg::ApplicationUsage::COMMAND_LINE_OPTION);
return 1;
}
#endif
std::string url, username, password;
while(arguments.read("--login",url, username, password))
{
if (!osgDB::Registry::instance()->getAuthenticationMap())
{
osgDB::Registry::instance()->setAuthenticationMap(new
osgDB::AuthenticationMap);
osgDB::Registry::instance()->getAuthenticationMap()->addAuthenticationDetails(
url,
new osgDB::AuthenticationDetails(username, password)
);
}
}
setupViewer(viewer.get(),arguments);
// load the data
osg::ref_ptr<osg::Node> loadedModel = osgDB::readNodeFiles(arguments);
if (!loadedModel)
{
loadedModel = createScene(arguments,viewer.get());
//arguments.getApplicationUsage()->write(std::cout,osg::ApplicationUsage::COMMAND_LINE_OPTION);
//std::cout << arguments.getApplicationName() <<": No data loaded" <<
std::endl;
//return 1;
}
// any option left unread are converted into errors to write out later.
arguments.reportRemainingOptionsAsUnrecognized();
// report any errors if they have occurred when parsing the program
arguments.
if (arguments.errors())
{
arguments.writeErrorMessages(std::cout);
return 1;
}
// optimize the scene graph, remove redundant nodes and state etc.
#if 0
osgUtil::Optimizer optimizer;
optimizer.optimize(loadedModel.get());
osgUtil::SmoothingVisitor sv;
loadedModel->accept(sv);
#endif
viewer->setSceneData( loadedModel.get() );
viewer->realize();
while (!viewer->done())
{
viewer->frame();
}
viewer = 0;
return 0;
}
_______________________________________________
osg-users mailing list
[email protected]
http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org
