Hi,
> Composing shaders is next to impossible in a general pupose way, each
> GLSL Program needs to know all the shaders that contribute to it and
> have a main shader that glues them all together.
Ok, I understand, this would be tricky indeed. And again hard-coded in
some (other) way ;-)
> I am aware of trying to mix shaders with self contained technique
> likes osgShadow has, so in a future rev I believe we'll need to make
> the osg::Program and the shaders that it uses publically accessible so
> users can write their own but leveraging the uniforms and shaders that
> the osgShadow routines use.
Hmm, that would be cool indeed. Another issue on the long list...
I actually meant another way of building a hierarchy of nodes with
shaders. Would something like:
scenedata
|
|-- osg::Node with fog osg::Program
|
|-- osgShadow::ShadowedScene
|
|-- models with proper shadow mask...
be possible? Or is this (also) not possible.
thanks
Raymond
>
> Robert.
>
> On Wed, Mar 19, 2008 at 2:42 PM, Raymond de Vries <[EMAIL PROTECTED]> wrote:
>> Aha, I guessed that, thanks for the confirmation.
>>
>> So you say that fog should be part of the shadow shader, and not a
>> separate, extra one. I did not do that much with shaders yet, except for
>> using the osg-included ones. I cannot have a hierarchy of nodes with
>> shaders, I guess?
>>
>> If I cannot have a hierarchy, should I be able to setup a RTT and apply
>> the fog shader to the RTTs stateset? I'd rather not put it in the shader
>> since it's not reusable then.
>>
>> Thanks again
>> Raymond
>>
>>
>>
>>
>> Robert Osfield wrote:
>> > HI Raynond,
>> >
>> > osg::Fog wraps up glFog, which is part of OpenGL's fixed function
>> > pipeline. As soon as you enable shaders you loose fog support unless
>> > you shaders directly include a fog shader in them.
>> >
>> > Robert.
>> >
>> > On Wed, Mar 19, 2008 at 2:26 PM, Raymond de Vries <[EMAIL PROTECTED]>
>> wrote:
>> >
>> >> Hi,
>> >>
>> >> I'm wondering if anyone tried the combination of SoftShadowMap shadows
>> >> and osg::Fog. With 2.2.0 and svn I've tried to use it with SoftShadowMap
>> >> but that's not working. I suspect that it's not working because of the
>> >> shader that's being used, but that's just a guess. ShadowTexture and
>> >> ShadowVolume (both fixed OpenGL) are both working ok with fog and the
>> >> other shadow techniques are not, and these are all using shaders.
>> >>
>> >> Is osg::Fog supposed to work with shadows based on shaders? Or more
>> >> general, is osg::Fog supposed to work in combination with shaders?
>> >>
>> >> thanks a lot
>> >> Raymond
>> >>
>> >> Please find attached the adapted osgshadow.cpp example
>> >>
>> >>
>> >> /* OpenSceneGraph example, osgshadow.
>> >> *
>> >> * Permission is hereby granted, free of charge, to any person
>> obtaining a copy
>> >> * of this software and associated documentation files (the
>> "Software"), to deal
>> >> * in the Software without restriction, including without limitation
>> the rights
>> >> * to use, copy, modify, merge, publish, distribute, sublicense, and/or
>> sell
>> >> * copies of the Software, and to permit persons to whom the Software is
>> >> * furnished to do so, subject to the following conditions:
>> >> *
>> >> * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
>> EXPRESS OR
>> >> * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
>> MERCHANTABILITY,
>> >> * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
>> SHALL THE
>> >> * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
>> OTHER
>> >> * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
>> ARISING FROM,
>> >> * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
>> DEALINGS IN
>> >> * THE SOFTWARE.
>> >> */
>> >>
>> >> #include <osg/ArgumentParser>
>> >> #include <osg/ComputeBoundsVisitor>
>> >> #include <osg/Texture2D>
>> >> #include <osg/ShapeDrawable>
>> >> #include <osg/MatrixTransform>
>> >> #include <osg/Fog>
>> >> #include <osg/Geometry>
>> >>
>> >> #include <osgGA/TrackballManipulator>
>> >> #include <osgGA/FlightManipulator>
>> >> #include <osgGA/DriveManipulator>
>> >> #include <osgGA/KeySwitchMatrixManipulator>
>> >> #include <osgGA/AnimationPathManipulator>
>> >> #include <osgGA/TerrainManipulator>
>> >> #include <osgGA/AnimationPathManipulator>
>> >> #include <osgGA/StateSetManipulator>
>> >>
>> >> #include <osgViewer/Viewer>
>> >> #include <osgViewer/ViewerEventHandlers>
>> >>
>> >> #include <osgShadow/ShadowedScene>
>> >> #include <osgShadow/ShadowVolume>
>> >> #include <osgShadow/ShadowTexture>
>> >> #include <osgShadow/ShadowMap>
>> >> #include <osgShadow/SoftShadowMap>
>> >> #include <osgShadow/ParallelSplitShadowMap>
>> >>
>> >> #include <osgDB/ReadFile>
>> >> #include <osgDB/WriteFile>
>> >>
>> >> #include <iostream>
>> >>
>> >> // for the grid data..
>> >> #include "../osghangglide/terrain_coords.h"
>> >>
>> >> const int ReceivesShadowTraversalMask = 0x1;
>> >> const int CastsShadowTraversalMask = 0x2;
>> >>
>> >> namespace ModelOne
>> >> {
>> >>
>> >> enum Faces
>> >> {
>> >> FRONT_FACE = 1,
>> >> BACK_FACE = 2,
>> >> LEFT_FACE = 4,
>> >> RIGHT_FACE = 8,
>> >> TOP_FACE = 16,
>> >> BOTTOM_FACE = 32
>> >> };
>> >>
>> >> osg::Node* createCube(unsigned int mask)
>> >> {
>> >> osg::Geode* geode = new osg::Geode;
>> >>
>> >> osg::Geometry* geometry = new osg::Geometry;
>> >> geode->addDrawable(geometry);
>> >>
>> >> osg::Vec3Array* vertices = new osg::Vec3Array;
>> >> geometry->setVertexArray(vertices);
>> >>
>> >> osg::Vec3Array* normals = new osg::Vec3Array;
>> >> geometry->setNormalArray(normals);
>> >> geometry->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
>> >>
>> >> osg::Vec4Array* colours = new osg::Vec4Array;
>> >> geometry->setColorArray(colours);
>> >> geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
>> >> colours->push_back(osg::Vec4(1.0f,1.0f,1.0f,1.0f));
>> >>
>> >>
>> >> osg::Vec3 origin(0.0f,0.0f,0.0f);
>> >> osg::Vec3 dx(2.0f,0.0f,0.0f);
>> >> osg::Vec3 dy(0.0f,1.0f,0.0f);
>> >> osg::Vec3 dz(0.0f,0.0f,1.0f);
>> >>
>> >> osg::Vec3 px(1.0f,0.0,0.0f);
>> >> osg::Vec3 nx(-1.0f,0.0,0.0f);
>> >> osg::Vec3 py(0.0f,1.0f,0.0f);
>> >> osg::Vec3 ny(0.0f,-1.0f,0.0f);
>> >> osg::Vec3 pz(0.0f,0.0f,1.0f);
>> >> osg::Vec3 nz(0.0f,0.0f,-1.0f);
>> >>
>> >> if (mask & FRONT_FACE)
>> >> {
>> >> // front face
>> >> vertices->push_back(origin);
>> >> vertices->push_back(origin+dx);
>> >> vertices->push_back(origin+dx+dz);
>> >> vertices->push_back(origin+dz);
>> >> normals->push_back(ny);
>> >> normals->push_back(ny);
>> >> normals->push_back(ny);
>> >> normals->push_back(ny);
>> >> }
>> >>
>> >> if (mask & BACK_FACE)
>> >> {
>> >> // back face
>> >> vertices->push_back(origin+dy);
>> >> vertices->push_back(origin+dy+dz);
>> >> vertices->push_back(origin+dy+dx+dz);
>> >> vertices->push_back(origin+dy+dx);
>> >> normals->push_back(py);
>> >> normals->push_back(py);
>> >> normals->push_back(py);
>> >> normals->push_back(py);
>> >> }
>> >>
>> >> if (mask & LEFT_FACE)
>> >> {
>> >> // left face
>> >> vertices->push_back(origin+dy);
>> >> vertices->push_back(origin);
>> >> vertices->push_back(origin+dz);
>> >> vertices->push_back(origin+dy+dz);
>> >> normals->push_back(nx);
>> >> normals->push_back(nx);
>> >> normals->push_back(nx);
>> >> normals->push_back(nx);
>> >> }
>> >>
>> >> if (mask & RIGHT_FACE)
>> >> {
>> >> // right face
>> >> vertices->push_back(origin+dx+dy);
>> >> vertices->push_back(origin+dx+dy+dz);
>> >> vertices->push_back(origin+dx+dz);
>> >> vertices->push_back(origin+dx);
>> >> normals->push_back(px);
>> >> normals->push_back(px);
>> >> normals->push_back(px);
>> >> normals->push_back(px);
>> >> }
>> >>
>> >> if (mask & TOP_FACE)
>> >> {
>> >> // top face
>> >> vertices->push_back(origin+dz);
>> >> vertices->push_back(origin+dz+dx);
>> >> vertices->push_back(origin+dz+dx+dy);
>> >> vertices->push_back(origin+dz+dy);
>> >> normals->push_back(pz);
>> >> normals->push_back(pz);
>> >> normals->push_back(pz);
>> >> normals->push_back(pz);
>> >> }
>> >>
>> >> if (mask & BOTTOM_FACE)
>> >> {
>> >> // bottom face
>> >> vertices->push_back(origin);
>> >> vertices->push_back(origin+dy);
>> >> vertices->push_back(origin+dx+dy);
>> >> vertices->push_back(origin+dx);
>> >> normals->push_back(nz);
>> >> normals->push_back(nz);
>> >> normals->push_back(nz);
>> >> normals->push_back(nz);
>> >> }
>> >>
>> >> geometry->addPrimitiveSet(new osg::DrawArrays(GL_QUADS, 0,
>> vertices->size()));
>> >>
>> >> return geode;
>> >> }
>> >>
>> >> class SwitchHandler : public osgGA::GUIEventHandler
>> >> {
>> >> public:
>> >>
>> >> SwitchHandler():
>> >> _childNum(0) {}
>> >>
>> >> virtual bool handle(const osgGA::GUIEventAdapter&
>> ea,osgGA::GUIActionAdapter& /*aa*/, osg::Object* object, osg::NodeVisitor*
>> /*nv*/)
>> >> {
>> >> osg::Switch* sw = dynamic_cast<osg::Switch*>(object);
>> >> if (!sw) return false;
>> >>
>> >> if (ea.getHandled()) return false;
>> >>
>> >> switch(ea.getEventType())
>> >> {
>> >> case(osgGA::GUIEventAdapter::KEYDOWN):
>> >> {
>> >> if (ea.getKey()=='n')
>> >> {
>> >> ++_childNum;
>> >> if (_childNum >= sw->getNumChildren()) _childNum
>> = 0;
>> >>
>> >> sw->setSingleChildOn(_childNum);
>> >> return true;
>> >> }
>> >> break;
>> >> }
>> >> default:
>> >> break;
>> >> }
>> >> return false;
>> >> }
>> >>
>> >> protected:
>> >>
>> >> virtual ~SwitchHandler() {}
>> >> unsigned int _childNum;
>> >>
>> >> };
>> >>
>> >>
>> >> osg::Node* createModel(osg::ArgumentParser& /*arguments*/)
>> >> {
>> >> osg::Switch* sw = new osg::Switch;
>> >> sw->setEventCallback(new ModelOne::SwitchHandler);
>> >>
>> >> sw->addChild(ModelOne::createCube(ModelOne::FRONT_FACE), true);
>> >> sw->addChild(ModelOne::createCube(ModelOne::FRONT_FACE |
>> ModelOne::BACK_FACE), false);
>> >> sw->addChild(ModelOne::createCube(ModelOne::FRONT_FACE |
>> ModelOne::BACK_FACE | ModelOne::LEFT_FACE), false);
>> >> sw->addChild(ModelOne::createCube(ModelOne::FRONT_FACE |
>> ModelOne::BACK_FACE | ModelOne::LEFT_FACE | ModelOne::RIGHT_FACE), false);
>> >> sw->addChild(ModelOne::createCube(ModelOne::FRONT_FACE |
>> ModelOne::BACK_FACE | ModelOne::LEFT_FACE | ModelOne::RIGHT_FACE |
>> ModelOne::TOP_FACE), false);
>> >> sw->addChild(ModelOne::createCube(ModelOne::FRONT_FACE |
>> ModelOne::BACK_FACE | ModelOne::LEFT_FACE | ModelOne::RIGHT_FACE |
>> ModelOne::TOP_FACE | ModelOne::BOTTOM_FACE), false);
>> >>
>> >> return sw;
>> >> }
>> >> }
>> >>
>> >> namespace ModelTwo
>> >> {
>> >> osg::AnimationPath* createAnimationPath(const osg::Vec3&
>> center,float radius,double looptime)
>> >> {
>> >> // set up the animation path
>> >> osg::AnimationPath* animationPath = new osg::AnimationPath;
>> >> animationPath->setLoopMode(osg::AnimationPath::LOOP);
>> >>
>> >> int numSamples = 40;
>> >> float yaw = 0.0f;
>> >> float yaw_delta = 2.0f*osg::PI/((float)numSamples-1.0f);
>> >> float roll = osg::inDegrees(30.0f);
>> >>
>> >> double time=0.0f;
>> >> double time_delta = looptime/(double)numSamples;
>> >> for(int i=0;i<numSamples;++i)
>> >> {
>> >> osg::Vec3
>> position(center+osg::Vec3(sinf(yaw)*radius,cosf(yaw)*radius,0.0f));
>> >> osg::Quat
>> rotation(osg::Quat(roll,osg::Vec3(0.0,1.0,0.0))*osg::Quat(-(yaw+osg::inDegrees(90.0f)),osg::Vec3(0.0,0.0,1.0)));
>> >>
>> >>
>> animationPath->insert(time,osg::AnimationPath::ControlPoint(position,rotation));
>> >>
>> >> yaw += yaw_delta;
>> >> time += time_delta;
>> >>
>> >> }
>> >> return animationPath;
>> >> }
>> >>
>> >> osg::Node* createBase(const osg::Vec3& center,float radius)
>> >> {
>> >>
>> >> osg::Geode* geode = new osg::Geode;
>> >>
>> >> // set up the texture of the base.
>> >> osg::StateSet* stateset = new osg::StateSet();
>> >> osg::Image* image = osgDB::readImageFile("Images/lz.rgb");
>> >> if (image)
>> >> {
>> >> osg::Texture2D* texture = new osg::Texture2D;
>> >> texture->setImage(image);
>> >>
>> stateset->setTextureAttributeAndModes(0,texture,osg::StateAttribute::ON);
>> >> }
>> >>
>> >> geode->setStateSet( stateset );
>> >>
>> >>
>> >> osg::HeightField* grid = new osg::HeightField;
>> >> grid->allocate(38,39);
>> >> grid->setOrigin(center+osg::Vec3(-radius,-radius,0.0f));
>> >> grid->setXInterval(radius*2.0f/(float)(38-1));
>> >> grid->setYInterval(radius*2.0f/(float)(39-1));
>> >>
>> >> float minHeight = FLT_MAX;
>> >> float maxHeight = -FLT_MAX;
>> >>
>> >>
>> >> unsigned int r;
>> >> for(r=0;r<39;++r)
>> >> {
>> >> for(unsigned int c=0;c<38;++c)
>> >> {
>> >> float h = vertex[r+c*39][2];
>> >> if (h>maxHeight) maxHeight=h;
>> >> if (h<minHeight) minHeight=h;
>> >> }
>> >> }
>> >>
>> >> float hieghtScale = radius*0.5f/(maxHeight-minHeight);
>> >> float hieghtOffset = -(minHeight+maxHeight)*0.5f;
>> >>
>> >> for(r=0;r<39;++r)
>> >> {
>> >> for(unsigned int c=0;c<38;++c)
>> >> {
>> >> float h = vertex[r+c*39][2];
>> >> grid->setHeight(c,r,(h+hieghtOffset)*hieghtScale);
>> >> }
>> >> }
>> >>
>> >> geode->addDrawable(new osg::ShapeDrawable(grid));
>> >>
>> >> osg::Group* group = new osg::Group;
>> >> group->addChild(geode);
>> >>
>> >> return group;
>> >>
>> >> }
>> >>
>> >> osg::Node* createMovingModel(const osg::Vec3& center, float radius)
>> >> {
>> >> float animationLength = 10.0f;
>> >>
>> >> osg::AnimationPath* animationPath =
>> createAnimationPath(center,radius,animationLength);
>> >>
>> >> osg::Group* model = new osg::Group;
>> >>
>> >> osg::Node* cessna = osgDB::readNodeFile("cessna.osg");
>> >> if (cessna)
>> >> {
>> >> const osg::BoundingSphere& bs = cessna->getBound();
>> >>
>> >> float size = radius/bs.radius()*0.3f;
>> >> osg::MatrixTransform* positioned = new osg::MatrixTransform;
>> >> positioned->setDataVariance(osg::Object::STATIC);
>> >> positioned->setMatrix(osg::Matrix::translate(-bs.center())*
>> >> osg::Matrix::scale(size,size,size)*
>> >>
>> osg::Matrix::rotate(osg::inDegrees(180.0f),0.0f,0.0f,2.0f));
>> >>
>> >> positioned->addChild(cessna);
>> >>
>> >> osg::MatrixTransform* xform = new osg::MatrixTransform;
>> >> xform->setUpdateCallback(new
>> osg::AnimationPathCallback(animationPath,0.0f,2.0));
>> >> xform->addChild(positioned);
>> >>
>> >> model->addChild(xform);
>> >> }
>> >>
>> >> return model;
>> >> }
>> >>
>> >> osg::Node* createModel(osg::ArgumentParser& /*arguments*/)
>> >> {
>> >> osg::Vec3 center(0.0f,0.0f,0.0f);
>> >> float radius = 100.0f;
>> >> osg::Vec3 lightPosition(center+osg::Vec3(0.0f,0.0f,radius));
>> >>
>> >> // the shadower model
>> >> osg::Node* shadower = createMovingModel(center,radius*0.5f);
>> >> shadower->setNodeMask(CastsShadowTraversalMask);
>> >>
>> >> // the shadowed model
>> >> osg::Node* shadowed =
>> createBase(center-osg::Vec3(0.0f,0.0f,radius*0.25),radius);
>> >> shadowed->setNodeMask(ReceivesShadowTraversalMask);
>> >>
>> >> osg::Group* group = new osg::Group;
>> >>
>> >> group->addChild(shadowed);
>> >> group->addChild(shadower);
>> >>
>> >> return group;
>> >> }
>> >> }
>> >>
>> >> namespace ModelThree
>> >> {
>> >> osg::Group* createModel(osg::ArgumentParser& arguments)
>> >> {
>> >> osg::Group* scene = new osg::Group;
>> >>
>> >> osg::ref_ptr<osg::Geode> geode_1 = new osg::Geode;
>> >> scene->addChild(geode_1.get());
>> >>
>> >> osg::ref_ptr<osg::Geode> geode_2 = new osg::Geode;
>> >> osg::ref_ptr<osg::MatrixTransform> transform_2 = new
>> osg::MatrixTransform;
>> >> transform_2->addChild(geode_2.get());
>> >> transform_2->setUpdateCallback(new
>> osg::AnimationPathCallback(osg::Vec3(0, 0, 0), osg::Z_AXIS,
>> osg::inDegrees(45.0f)));
>> >> scene->addChild(transform_2.get());
>> >>
>> >> osg::ref_ptr<osg::Geode> geode_3 = new osg::Geode;
>> >> osg::ref_ptr<osg::MatrixTransform> transform_3 = new
>> osg::MatrixTransform;
>> >> transform_3->addChild(geode_3.get());
>> >> transform_3->setUpdateCallback(new
>> osg::AnimationPathCallback(osg::Vec3(0, 0, 0), osg::Z_AXIS,
>> osg::inDegrees(-22.5f)));
>> >> scene->addChild(transform_3.get());
>> >>
>> >> const float radius = 0.8f;
>> >> const float height = 1.0f;
>> >> osg::ref_ptr<osg::TessellationHints> hints = new
>> osg::TessellationHints;
>> >> hints->setDetailRatio(2.0f);
>> >> osg::ref_ptr<osg::ShapeDrawable> shape;
>> >>
>> >> shape = new osg::ShapeDrawable(new osg::Box(osg::Vec3(0.0f,
>> 0.0f, -2.0f), 10, 10.0f, 0.1f), hints.get());
>> >> shape->setColor(osg::Vec4(0.5f, 0.5f, 0.7f, 1.0f));
>> >> geode_1->addDrawable(shape.get());
>> >>
>> >> shape = new osg::ShapeDrawable(new osg::Sphere(osg::Vec3(0.0f,
>> 0.0f, 0.0f), radius * 2), hints.get());
>> >> shape->setColor(osg::Vec4(0.8f, 0.8f, 0.8f, 1.0f));
>> >> geode_1->addDrawable(shape.get());
>> >>
>> >> shape = new osg::ShapeDrawable(new osg::Sphere(osg::Vec3(-3.0f,
>> 0.0f, 0.0f), radius), hints.get());
>> >> shape->setColor(osg::Vec4(0.6f, 0.8f, 0.8f, 1.0f));
>> >> geode_2->addDrawable(shape.get());
>> >>
>> >> shape = new osg::ShapeDrawable(new osg::Box(osg::Vec3(3.0f,
>> 0.0f, 0.0f), 2 * radius), hints.get());
>> >> shape->setColor(osg::Vec4(0.4f, 0.9f, 0.3f, 1.0f));
>> >> geode_2->addDrawable(shape.get());
>> >>
>> >> shape = new osg::ShapeDrawable(new osg::Cone(osg::Vec3(0.0f,
>> -3.0f, 0.0f), radius, height), hints.get());
>> >> shape->setColor(osg::Vec4(0.2f, 0.5f, 0.7f, 1.0f));
>> >> geode_2->addDrawable(shape.get());
>> >>
>> >> shape = new osg::ShapeDrawable(new osg::Cylinder(osg::Vec3(0.0f,
>> 3.0f, 0.0f), radius, height), hints.get());
>> >> shape->setColor(osg::Vec4(1.0f, 0.3f, 0.3f, 1.0f));
>> >> geode_2->addDrawable(shape.get());
>> >>
>> >> shape = new osg::ShapeDrawable(new osg::Box(osg::Vec3(0.0f,
>> 0.0f, 3.0f), 2.0f, 2.0f, 0.1f), hints.get());
>> >> shape->setColor(osg::Vec4(0.8f, 0.8f, 0.4f, 1.0f));
>> >> geode_3->addDrawable(shape.get());
>> >>
>> >> // material
>> >> osg::ref_ptr<osg::Material> matirial = new osg::Material;
>> >> matirial->setColorMode(osg::Material::DIFFUSE);
>> >> matirial->setAmbient(osg::Material::FRONT_AND_BACK, osg::Vec4(0,
>> 0, 0, 1));
>> >> matirial->setSpecular(osg::Material::FRONT_AND_BACK,
>> osg::Vec4(1, 1, 1, 1));
>> >> matirial->setShininess(osg::Material::FRONT_AND_BACK, 64.0f);
>> >>
>> scene->getOrCreateStateSet()->setAttributeAndModes(matirial.get(),
>> osg::StateAttribute::ON);
>> >>
>> >> bool withBaseTexture = true;
>> >> while(arguments.read("--with-base-texture")) { withBaseTexture =
>> true; }
>> >> while(arguments.read("--no-base-texture")) { withBaseTexture =
>> false; }
>> >>
>> >> if (withBaseTexture)
>> >> {
>> >> scene->getOrCreateStateSet()->setTextureAttributeAndModes(
>> 0, new osg::Texture2D(osgDB::readImageFile("Images/lz.rgb")),
>> osg::StateAttribute::ON);
>> >> }
>> >>
>> >> return scene;
>> >> }
>> >>
>> >> }
>> >>
>> >>
>> >> osg::Node* createTestModel(osg::ArgumentParser& arguments)
>> >> {
>> >> if (arguments.read("-1"))
>> >> {
>> >> return ModelOne::createModel(arguments);
>> >> }
>> >> else if (arguments.read("-2"))
>> >> {
>> >> return ModelTwo::createModel(arguments);
>> >> }
>> >> else /*if (arguments.read("-3"))*/
>> >> {
>> >> return ModelThree::createModel(arguments);
>> >> }
>> >>
>> >> }
>> >>
>> >> int main(int argc, char** argv)
>> >> {
>> >> // use an ArgumentParser object to manage the program arguments.
>> >> osg::ArgumentParser arguments(&argc, argv);
>> >>
>> >> // set up the usage document, in case we need to print out how to
>> use this program.
>> >>
>> arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()
>> + " is the example which demonstrates using of GL_ARB_shadow extension
>> implemented in osg::Texture class");
>> >>
>> arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName());
>> >> arguments.getApplicationUsage()->addCommandLineOption("-h or
>> --help", "Display this information");
>> >>
>> arguments.getApplicationUsage()->addCommandLineOption("--positionalLight",
>> "Use a positional light.");
>> >>
>> arguments.getApplicationUsage()->addCommandLineOption("--directionalLight",
>> "Use a direction light.");
>> >> arguments.getApplicationUsage()->addCommandLineOption("--noUpdate",
>> "Disable the updating the of light source.");
>> >> arguments.getApplicationUsage()->addCommandLineOption("--base", "Add
>> a base geometry to test shadows.");
>> >> arguments.getApplicationUsage()->addCommandLineOption("--sv",
>> "Select ShadowVolume implementation.");
>> >> arguments.getApplicationUsage()->addCommandLineOption("--ssm",
>> "Select SoftShadowMap implementation.");
>> >> arguments.getApplicationUsage()->addCommandLineOption("--sm",
>> "Select ShadowMap implementation.");
>> >> // arguments.getApplicationUsage()->addCommandLineOption("--pssm",
>> "Select ParallelSplitShadowMap implementation.");
>> >> arguments.getApplicationUsage()->addCommandLineOption("--pssm",
>> "Select ParallelSplitShadowMap implementation.");//ADEGLI
>> >> arguments.getApplicationUsage()->addCommandLineOption("--mapcount",
>> "ParallelSplitShadowMap texture count.");//ADEGLI
>> >> arguments.getApplicationUsage()->addCommandLineOption("--mapres",
>> "ParallelSplitShadowMap texture resolution.");//ADEGLI
>> >>
>> arguments.getApplicationUsage()->addCommandLineOption("--debug-color",
>> "ParallelSplitShadowMap display debugging color (only the first 3 maps are
>> color r=0,g=1,b=2.");//ADEGLI
>> >>
>> arguments.getApplicationUsage()->addCommandLineOption("--minNearSplit",
>> "ParallelSplitShadowMap shadow map near offset.");//ADEGLI
>> >>
>> arguments.getApplicationUsage()->addCommandLineOption("--maxFarDist",
>> "ParallelSplitShadowMap max far distance to shadow.");//ADEGLI
>> >>
>> arguments.getApplicationUsage()->addCommandLineOption("--moveVCamFactor",
>> "ParallelSplitShadowMap move the virtual frustum behind the real camera,
>> (also back ground object can cast shadow).");//ADEGLI
>> >> arguments.getApplicationUsage()->addCommandLineOption("--NVidia",
>> "ParallelSplitShadowMap set default PolygonOffset for NVidia.");//ADEGLI
>> >>
>> arguments.getApplicationUsage()->addCommandLineOption("--PolyOffset-Factor",
>> "ParallelSplitShadowMap set PolygonOffset factor.");//ADEGLI
>> >>
>> arguments.getApplicationUsage()->addCommandLineOption("--PolyOffset-Unit",
>> "ParallelSplitShadowMap set PolygonOffset unit.");//ADEGLI
>> >>
>> arguments.getApplicationUsage()->addCommandLineOption("--CullFaceFront",
>> "ParallelSplitShadowMap add a cull face: front.");//ADEGLI
>> >>
>> >>
>> >> arguments.getApplicationUsage()->addCommandLineOption("-1", "Use
>> test model one.");
>> >> arguments.getApplicationUsage()->addCommandLineOption("-2", "Use
>> test model two.");
>> >> arguments.getApplicationUsage()->addCommandLineOption("-3", "Use
>> test model three.");
>> >> arguments.getApplicationUsage()->addCommandLineOption("--two-sided",
>> "Use two-sided stencil extension for shadow volumes.");
>> >> arguments.getApplicationUsage()->addCommandLineOption("--two-pass",
>> "Use two-pass stencil for shadow volumes.");
>> >>
>> >>
>> >> // construct the viewer.
>> >> osgViewer::Viewer viewer(arguments);
>> >>
>> >> // if user request help write it out to cout.
>> >> if (arguments.read("-h") || arguments.read("--help"))
>> >> {
>> >> arguments.getApplicationUsage()->write(std::cout);
>> >> return 1;
>> >> }
>> >>
>> >> // default to single threaded during dev work.
>> >> viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded);
>> >>
>> >> while (arguments.read("--SingleThreaded"))
>> viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded);
>> >> while (arguments.read("--CullDrawThreadPerContext"))
>> viewer.setThreadingModel(osgViewer::Viewer::CullDrawThreadPerContext);
>> >> while (arguments.read("--DrawThreadPerContext"))
>> viewer.setThreadingModel(osgViewer::Viewer::DrawThreadPerContext);
>> >> while (arguments.read("--CullThreadPerCameraDrawThreadPerContext"))
>> viewer.setThreadingModel(osgViewer::Viewer::CullThreadPerCameraDrawThreadPerContext);
>> >>
>> >>
>> >> bool postionalLight = true;
>> >> while (arguments.read("--positionalLight")) postionalLight = true;
>> >> while (arguments.read("--directionalLight")) postionalLight = false;
>> >>
>> >> bool updateLightPosition = true;
>> >> while (arguments.read("--noUpdate")) updateLightPosition = false;
>> >>
>> >>
>> >> int screenNum = -1;
>> >> while (arguments.read("--screen", screenNum))
>> viewer.setUpViewOnSingleScreen(screenNum);
>> >>
>> >> // 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() );
>> >>
>> >> std::string pathfile;
>> >> char keyForAnimationPath = '5';
>> >> while (arguments.read("-p",pathfile))
>> >> {
>> >> osgGA::AnimationPathManipulator* apm = new
>> osgGA::AnimationPathManipulator(pathfile);
>> >> if (apm || !apm->valid())
>> >> {
>> >> unsigned int num =
>> keyswitchManipulator->getNumMatrixManipulators();
>> >> keyswitchManipulator->addMatrixManipulator(
>> keyForAnimationPath, "Path", apm );
>> >> keyswitchManipulator->selectMatrixManipulator(num);
>> >> ++keyForAnimationPath;
>> >> }
>> >> }
>> >>
>> >> viewer.setCameraManipulator( keyswitchManipulator.get() );
>> >> }
>> >>
>> >> // add the state manipulator
>> >> viewer.addEventHandler( new
>> osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) );
>> >>
>> >> // add stats
>> >> viewer.addEventHandler( new osgViewer::StatsHandler() );
>> >>
>> >> // add the record camera path handler
>> >> viewer.addEventHandler(new osgViewer::RecordCameraPathHandler);
>> >>
>> >>
>> >> osg::ref_ptr<osgShadow::ShadowedScene> shadowedScene = new
>> osgShadow::ShadowedScene;
>> >>
>> >>
>> shadowedScene->setReceivesShadowTraversalMask(ReceivesShadowTraversalMask);
>> >> shadowedScene->setCastsShadowTraversalMask(CastsShadowTraversalMask);
>> >>
>> >>
>> >> if (arguments.read("--sv"))
>> >> {
>> >> // hint to tell viewer to request stencil buffer when setting up
>> windows
>> >> osg::DisplaySettings::instance()->setMinimumNumStencilBits(8);
>> >>
>> >> osg::ref_ptr<osgShadow::ShadowVolume> sv = new
>> osgShadow::ShadowVolume;
>> >> sv->setDynamicShadowVolumes(updateLightPosition);
>> >> while (arguments.read("--two-sided"))
>> sv->setDrawMode(osgShadow::ShadowVolumeGeometry::STENCIL_TWO_SIDED);
>> >> while (arguments.read("--two-pass"))
>> sv->setDrawMode(osgShadow::ShadowVolumeGeometry::STENCIL_TWO_PASS);
>> >>
>> >> shadowedScene->setShadowTechnique(sv.get());
>> >> }
>> >> else if (arguments.read("--st"))
>> >> {
>> >> osg::ref_ptr<osgShadow::ShadowTexture> st = new
>> osgShadow::ShadowTexture;
>> >> shadowedScene->setShadowTechnique(st.get());
>> >> }
>> >> else if (arguments.read("--pssm"))
>> >> {
>> >> int mapcount = 3;
>> >> while (arguments.read("--mapcount", mapcount));
>> >> osg::ref_ptr<osgShadow::ParallelSplitShadowMap> pssm = new
>> osgShadow::ParallelSplitShadowMap(NULL,mapcount);
>> >>
>> >> int mapres = 1024;
>> >> while (arguments.read("--mapres", mapres))
>> >> pssm->setTextureResolution(mapres);
>> >>
>> >> while (arguments.read("--debug-color")) {
>> pssm->setDebugColorOn(); }
>> >>
>> >>
>> >> int minNearSplit=0;
>> >> while (arguments.read("--minNearSplit", minNearSplit))
>> >> if ( minNearSplit > 0 ) {
>> >> pssm->setMinNearDistanceForSplits(minNearSplit);
>> >> std::cout << "ParallelSplitShadowMap :
>> setMinNearDistanceForSplits(" << minNearSplit <<")" << std::endl;
>> >> }
>> >>
>> >> int maxfardist = 0;
>> >> while (arguments.read("--maxFarDist", maxfardist))
>> >> if ( maxfardist > 0 ) {
>> >> pssm->setMaxFarDistance(maxfardist);
>> >> std::cout << "ParallelSplitShadowMap :
>> setMaxFarDistance(" << maxfardist<<")" << std::endl;
>> >> }
>> >>
>> >> int moveVCamFactor = 0;
>> >> while (arguments.read("--moveVCamFactor", moveVCamFactor))
>> >> if ( maxfardist > 0 ) {
>> >> pssm->setMoveVCamBehindRCamFactor(moveVCamFactor);
>> >> std::cout << "ParallelSplitShadowMap :
>> setMoveVCamBehindRCamFactor(" << moveVCamFactor<<")" << std::endl;
>> >> }
>> >>
>> >>
>> >> double polyoffsetfactor = -0.02;
>> >> double polyoffsetunit = 1.0;
>> >> while (arguments.read("--PolyOffset-Factor", polyoffsetfactor));
>> >> while (arguments.read("--PolyOffset-Unit", polyoffsetunit));
>> >>
>> pssm->setPolygonOffset(osg::Vec2(polyoffsetfactor,polyoffsetunit)); //ATI
>> Radeon
>> >>
>> >> if (arguments.read("--NVidia")){
>> >> //pssm->setPolygonOffset(osg::Vec2(-0.02,1.0)); //ATI Radeon
>> >> pssm->setPolygonOffset(osg::Vec2(10.0f,20.0f)); //NVidia
>> >> }
>> >>
>> >> if ( arguments.read("--CullFaceFront") ) {
>> >> pssm->forceFrontCullFace();
>> >> }
>> >>
>> >> shadowedScene->setShadowTechnique(pssm.get());
>> >> }
>> >> else if (arguments.read("--ssm"))
>> >> {
>> >> osg::ref_ptr<osgShadow::SoftShadowMap> sm = new
>> osgShadow::SoftShadowMap;
>> >> shadowedScene->setShadowTechnique(sm.get());
>> >> }
>> >> else /* if (arguments.read("--sm")) */
>> >> {
>> >> osg::ref_ptr<osgShadow::ShadowMap> sm = new osgShadow::ShadowMap;
>> >> shadowedScene->setShadowTechnique(sm.get());
>> >>
>> >> int mapres = 1024;
>> >> while (arguments.read("--mapres", mapres))
>> >> sm->setTextureSize(osg::Vec2s(mapres,mapres));
>> >> }
>> >>
>> >> osg::ref_ptr<osg::Node> model = osgDB::readNodeFiles(arguments);
>> >> if (model.valid())
>> >> {
>> >> model->setNodeMask(CastsShadowTraversalMask |
>> ReceivesShadowTraversalMask);
>> >> }
>> >> else
>> >> {
>> >> model = createTestModel(arguments);
>> >> }
>> >>
>> >> // RdV osg::Fog test
>> >> osg::ref_ptr<osg::Fog> fog = new osg::Fog;
>> >> fog->setStart(25.0);
>> >> fog->setEnd(200.0);
>> >> fog->setDensity(0.01);
>> >> fog->setColor(osg::Vec4(0.5, 0.5, 0.5, 1.0));
>> >> fog->setMode(osg::Fog::EXP);
>> >> // Add fog to the model
>> >> model->getOrCreateStateSet()->setAttributeAndModes(fog.get());
>> >> // end RdV osg::Fog test
>> >>
>> >> // get the bounds of the model.
>> >> osg::ComputeBoundsVisitor cbbv;
>> >> model->accept(cbbv);
>> >> osg::BoundingBox bb = cbbv.getBoundingBox();
>> >>
>> >> osg::Vec4 lightpos;
>> >>
>> >> if (postionalLight)
>> >> {
>> >> lightpos.set(bb.center().x(), bb.center().y(), bb.zMax() +
>> bb.radius()*2.0f ,1.0f);
>> >> }
>> >> else
>> >> {
>> >> lightpos.set(0.5f,0.25f,0.8f,0.0f);
>> >> }
>> >>
>> >>
>> >> if ( arguments.read("--base"))
>> >> {
>> >>
>> >> osg::Geode* geode = new osg::Geode;
>> >>
>> >> osg::Vec3 widthVec(bb.radius(), 0.0f, 0.0f);
>> >> osg::Vec3 depthVec(0.0f, bb.radius(), 0.0f);
>> >> osg::Vec3 centerBase( (bb.xMin()+bb.xMax())*0.5f,
>> (bb.yMin()+bb.yMax())*0.5f, bb.zMin()-bb.radius()*0.1f );
>> >>
>> >> geode->addDrawable( osg::createTexturedQuadGeometry(
>> centerBase-widthVec*1.5f-depthVec*1.5f,
>> >>
>> widthVec*3.0f, depthVec*3.0f) );
>> >>
>> >>
>> geode->setNodeMask(shadowedScene->getReceivesShadowTraversalMask());
>> >>
>> >> geode->getOrCreateStateSet()->setTextureAttributeAndModes(0, new
>> osg::Texture2D(osgDB::readImageFile("Images/lz.rgb")));
>> >>
>> >> shadowedScene->addChild(geode);
>> >> }
>> >>
>> >> osg::ref_ptr<osg::LightSource> ls = new osg::LightSource;
>> >> ls->getLight()->setPosition(lightpos);
>> >>
>> >> bool spotlight = false;
>> >> if (arguments.read("--spotLight"))
>> >> {
>> >> spotlight = true;
>> >>
>> >> osg::Vec3 center = bb.center();
>> >> osg::Vec3 lightdir = center - osg::Vec3(lightpos.x(),
>> lightpos.y(), lightpos.z());
>> >> lightdir.normalize();
>> >> ls->getLight()->setDirection(lightdir);
>> >> ls->getLight()->setSpotCutoff(25.0f);
>> >>
>> >> //set the LightSource, only for checking, there is only 1 light
>> in the scene
>> >>
>> dynamic_cast<osgShadow::ShadowMap*>(shadowedScene->getShadowTechnique())->setLight(ls.get());
>> >> }
>> >>
>> >> if ( arguments.read("--coloured-light"))
>> >> {
>> >> ls->getLight()->setAmbient(osg::Vec4(1.0,0.0,0.0,1.0));
>> >> ls->getLight()->setDiffuse(osg::Vec4(0.0,1.0,0.0,1.0));
>> >> }
>> >> else
>> >> {
>> >> ls->getLight()->setAmbient(osg::Vec4(0.2,0.2,0.2,1.0));
>> >> ls->getLight()->setDiffuse(osg::Vec4(0.8,0.8,0.8,1.0));
>> >> }
>> >>
>> >> shadowedScene->addChild(model.get());
>> >> shadowedScene->addChild(ls.get());
>> >>
>> >> viewer.setSceneData(shadowedScene.get());
>> >>
>> >> // create the windows and run the threads.
>> >> viewer.realize();
>> >>
>> >> // it is done after viewer.realize() so that the windows are already
>> initialized
>> >> if ( arguments.read("--debugHUD"))
>> >> {
>> >> osgViewer::Viewer::Windows windows;
>> >> viewer.getWindows(windows);
>> >>
>> >> if (windows.empty()) return 1;
>> >>
>> >> osgShadow::ShadowMap* sm =
>> dynamic_cast<osgShadow::ShadowMap*>(shadowedScene->getShadowTechnique());
>> >> osg::ref_ptr<osg::Camera> hudCamera = sm->makeDebugHUD();
>> >>
>> >> // set up cameras to rendering on the first window available.
>> >> hudCamera->setGraphicsContext(windows[0]);
>> >> hudCamera->setViewport(0,0,windows[0]->getTraits()->width,
>> windows[0]->getTraits()->height);
>> >>
>> >> viewer.addSlave(hudCamera.get(), false);
>> >> }
>> >>
>> >>
>> >> // osgDB::writeNodeFile(*group,"test.osg");
>> >>
>> >> while (!viewer.done())
>> >> {
>> >> if (updateLightPosition)
>> >> {
>> >> float t = viewer.getFrameStamp()->getSimulationTime();
>> >> if (postionalLight)
>> >> {
>> >> lightpos.set(bb.center().x()+sinf(t)*bb.radius(),
>> bb.center().y() + cosf(t)*bb.radius(), bb.zMax() + bb.radius()*3.0f ,1.0f);
>> >> }
>> >> else
>> >> {
>> >> lightpos.set(sinf(t),cosf(t),1.0f,0.0f);
>> >> }
>> >> ls->getLight()->setPosition(lightpos);
>> >>
>> >> osg::Vec3f
>> lightDir(-lightpos.x(),-lightpos.y(),-lightpos.z());
>> >> if(spotlight)
>> >> lightDir =
>> osg::Vec3(bb.center().x()+sinf(t)*bb.radius()/2.0, bb.center().y() +
>> cosf(t)*bb.radius()/2.0, bb.center().z())
>> >> - osg::Vec3(lightpos.x(), lightpos.y(), lightpos.z()) ;
>> >> lightDir.normalize();
>> >> ls->getLight()->setDirection(lightDir);
>> >> }
>> >>
>> >> viewer.frame();
>> >> }
>> >>
>> >> return 0;
>> >> }
>> >>
>> >> _______________________________________________
>> >> 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
>> >
>> >
>> >
>>
>> _______________________________________________
>> 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
>
>
_______________________________________________
osg-users mailing list
[email protected]
http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org
