osg 获取深度纹理

xxxx

想获取深度纹理 然后传给Shader ，深度纹理没有值 但场景有阴影

1. // osgTest.cpp : Defines the entry point for the console application.
   
2. //
   
3. 
   
4. #include "stdafx.h"
   
5. 
   
6. 
   
7. #include <osg/ComputeBoundsVisitor>
   
8. #include <osg/MatrixTransform>
   
9. #include <osg/ShapeDrawable>
   
10. #include <osgUtil/Tessellator>
    
11. #include <osg/CullFace>
    
12. #include <osg/PolygonOffset>
    
13. #include <osg/StateSet>
    
14. #include <osg/TexGen>
    
15. #include <osg/Program>
    
16. #include <osg/Light>
    
17. #include <osg/LightSource>
    
18. #include <osg/PositionAttitudeTransform>
    
19. 
    
20. #include <osgDB/ReadFile>
    
21. 
    
22. #include <osgGA/DriveManipulator>
    
23. 
    
24. #include <osgViewer/Viewer>
    
25. #include <osgViewer/ViewerEventHandlers>
    
26. 
    
27. #include <osgWidget/PdfReader>
    
28. 
    
29. #include <osgShadow/ShadowedScene>
    
30. #include <osgShadow/SoftShadowMap>
    
31. 
    
32. 
    
33. static int ReceivesShadowTraversalMask = 0x1;
    
34. static int CastsShadowTraversalMask = 0x2;
    
35. osg::Vec3 eyePos(0,0.0,10);
    
36. osg::Vec3 targetPos(0.0,0.0,0.0);
    
37. 
    
38. class CameraUpdateCallBack:public osg::NodeCallback
    
39. {
    
40. public:
    
41.     CameraUpdateCallBack(osg::MatrixTransform*mat): _eye(0.0f,0,0)
    
42.     {
    
43.         _mat=mat;
    
44.     }
    
45.    
    
46.     virtual ~CameraUpdateCallBack(){
    
47.         
    
48.     }
    
49.     virtual void operator()(osg::Node*node,osg::NodeVisitor*nv){
    
50.         osg::Camera*camera = dynamic_cast<osg::Camera*>(node);
    
51.         if(camera){
    
52.             //      if(camera->getName().compare("MasterCamera")==0){
    
53.             osg::Vec3 eye,center,up;
    
54.             double left,right,bottom,top,znear,zfar;
    
55.             camera->getViewMatrixAsLookAt(eye, center, up);
    
56.             camera->getProjectionMatrixAsOrtho(left, right, bottom, top, znear, zfar);
    
57.             
    
58.             _eye=eye;//记录相机坐标
    
59.             
    
60.         }
    
61.         //    osg::MatrixTransform*mat=dynamic_cast<osg::MatrixTransform*>(node);
    
62.         if(_mat){
    
63.             osg::Matrix mm=_mat->getMatrix();
    
64.             osg::Vec3 _eyeTmp=mm.getTrans();
    
65.             mm.makeTranslate(_eyeTmp);
    
66.             _mat->setMatrix(mm);
    
67.             osg::Matrix m;
    
68.             m.makeTranslate(_eye);
    
69.             _mat->setMatrix(m);
    
70.         }
    
71.         traverse(node, nv);
    
72.     }
    
73. private:
    
74.     osg::Vec3 _eye;
    
75.     osg::MatrixTransform *_mat;
    
76.    
    
77. };
    
78. 
    
79. static const char fragmentShaderSource_noBaseTexture[] =
    
80. "uniform sampler2DShadow osgShadow_shadowTexture; \n"
    
81. "uniform vec2 osgShadow_ambientBias; \n"
    
82. "\n"
    
83. "void main(void) \n"
    
84. "{ \n"
    
85. "    gl_FragColor =  vec4(1.0f,0.0f,0.0f,0.0f); \n"
    
86. "}\n";
    
87. 
    
88. 
    
89. 
    
90. 
    
91. class shadow_X;
    
92. 
    
93. class CameraCullCallbackA : public osg::NodeCallback
    
94. {
    
95. public:
    
96.     CameraCullCallbackA(shadow_X *s)
    
97.     {
    
98.         __shadow = s;
    
99.     }
    
100.     virtual void operator()(osg::Node*, osg::NodeVisitor* nv);
     
101. protected:
     
102.     shadow_X* __shadow;
     
103. };
     
104. 
     
105. class shadow_X:public osg::Object
     
106. {
     
107. public:
     
108.     shadow_X(){
     
109.         _textureSize = osg::Vec2(1024,1024) ;_dirty = true;
     
110.         _baseTextureUnit = 0;
     
111.         _shadowTextureUnit = 1;
     
112.     }
     
113.          shadow_X(const shadow_X& es, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY): osg::Object(es,copyop)
     
114.          {
     
115.                
     
116.          }
     
117.         META_Object(osgshadow_X, shadow_X);
     
118.     void traverse(osg::NodeVisitor& nv)
     
119.     {
     
120.         if (_dirty) init();
     
121.         if (nv.getVisitorType() == osg::NodeVisitor::UPDATE_VISITOR)
     
122.         {
     
123.             update(nv);
     
124.         }
     
125.         
     
126.         if (nv.getVisitorType() == osg::NodeVisitor::CULL_VISITOR)
     
127.         {
     
128.             osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(&nv);
     
129.             if (cv)
     
130.                 cull(*cv);
     
131.             else
     
132.                 _scene->osg::Group::traverse(nv);
     
133.         }
     
134.         else
     
135.         {
     
136.             _scene->osg::Group::traverse(nv);
     
137.         }
     
138.     }
     
139.     void cull(osgUtil::CullVisitor& cv)
     
140.     {
     
141.         // record the traversal mask on entry so we can reapply it later.
     
142.         unsigned int traversalMask = cv.getTraversalMask();
     
143.         
     
144.         osgUtil::RenderStage* orig_rs = cv.getRenderStage();
     
145.         
     
146.         // do traversal of shadow recieving scene which does need to be decorated by the shadow map
     
147.         {
     
148.             cv.pushStateSet(_stateset.get());
     
149.             
     
150.             _scene->osg::Group::traverse(cv);
     
151.             
     
152.             cv.popStateSet();
     
153.             
     
154.         }
     
155.         
     
156.         cv.setTraversalMask( traversalMask );//????
     
157.         
     
158.         // do RTT camera traversal
     
159.         _camera->accept(cv);
     
160.         
     
161.         _texgen->setMode(osg::TexGen::EYE_LINEAR);
     
162.         
     
163.         // compute the matrix which takes a vertex from local coords into tex coords
     
164.         // We actually use two matrices one used to define texgen
     
165.         // and second that will be used as modelview when appling to OpenGL
     
166.         _texgen->setPlanesFromMatrix( _camera->getProjectionMatrix() *
     
167.                                      osg::Matrix::translate(1.0,1.0,1.0) *
     
168.                                      osg::Matrix::scale(0.5f,0.5f,0.5f) );
     
169.         
     
170.         // Place texgen with modelview which removes big offsets (making it float friendly)
     
171.         osg::RefMatrix * refMatrix = new osg::RefMatrix
     
172.         ( _camera->getInverseViewMatrix() * *cv.getModelViewMatrix() );
     
173.         
     
174.         cv.getRenderStage()->getPositionalStateContainer()->
     
175.         addPositionedTextureAttribute( _shadowTextureUnit, refMatrix, _texgen.get() );
     
176.         
     
177.     }
     
178.     void initTexture()
     
179.     {
     
180.         _texture = new osg::Texture2D;
     
181.         _texture->setTextureSize(_textureSize.x(), _textureSize.y());
     
182.         _texture->setInternalFormat(GL_DEPTH_COMPONENT);
     
183.         _texture->setShadowComparison(true);
     
184.         _texture->setShadowTextureMode(osg::Texture2D::LUMINANCE);
     
185.         _texture->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR);
     
186.         _texture->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::LINEAR);
     
187.         
     
188.         _texture->setWrap(osg::Texture2D::WRAP_S,osg::Texture2D::CLAMP_TO_BORDER);
     
189.         _texture->setWrap(osg::Texture2D::WRAP_T,osg::Texture2D::CLAMP_TO_BORDER);
     
190.         _texture->setBorderColor(osg::Vec4(1.0f,1.0f,1.0f,1.0f)); //边缘部分深度全为1
     
191.     }
     
192.    
     
193.     void initRTTCamera()
     
194.     {
     
195.         _camera = new osg::Camera;
     
196.         _camera->setReferenceFrame(osg::Camera::ABSOLUTE_RF_INHERIT_VIEWPOINT);//???
     
197.         _camera->setCullCallback(new CameraCullCallbackA(this));
     
198.         
     
199.         _camera->setClearMask(GL_DEPTH_BUFFER_BIT);
     
200.         _camera->setClearColor(osg::Vec4(1.0f,1.0f,1.0f,1.0f));
     
201.         _camera->setComputeNearFarMode(osg::Camera::DO_NOT_COMPUTE_NEAR_FAR);
     
202.         _camera->setViewport(0,0,_textureSize.x(),_textureSize.y());
     
203.         _camera->setViewMatrixAsLookAt(eyePos,targetPos,osg::Vec3(0,-1,0));
     
204.         double aspectRatio=1.0;
     
205.         double dNear=0.1;
     
206.         double dFar=10;
     
207.         _camera->setProjectionMatrixAsPerspective(45,aspectRatio,dNear,dFar);
     
208.         _camera->setRenderOrder(osg::Camera::PRE_RENDER);
     
209.         _camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT);
     
210.         _camera->attach(osg::Camera::DEPTH_BUFFER, _texture.get());
     
211.         
     
212.         
     
213.         osg::StateSet* stateset = _camera->getOrCreateStateSet();
     
214.         
     
215.         osg::ref_ptr<osg::CullFace> cull_face = new osg::CullFace;
     
216.         cull_face->setMode(osg::CullFace::FRONT);
     
217.         stateset->setAttribute(cull_face.get(), osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE);
     
218.         stateset->setMode(GL_CULL_FACE, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE);
     
219.         
     
220.         float factor = -1.0;
     
221.         float units =  -1.0;
     
222.         
     
223.         osg::ref_ptr<osg::PolygonOffset> polygon_offset = new osg::PolygonOffset;
     
224.         polygon_offset->setFactor(factor);
     
225.         polygon_offset->setUnits(units);
     
226.         stateset->setAttribute(polygon_offset.get(), osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE);
     
227.         stateset->setMode(GL_POLYGON_OFFSET_FILL, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE);
     
228.     }
     
229.    
     
230.     void createStateSet()
     
231.     {
     
232.         
     
233.         _stateset = new osg::StateSet;
     
234.         _stateset->setTextureAttributeAndModes(_shadowTextureUnit,_texture.get(),osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE);
     
235.         _stateset->setTextureMode(_shadowTextureUnit,GL_TEXTURE_GEN_S,osg::StateAttribute::ON);
     
236.         _stateset->setTextureMode(_shadowTextureUnit,GL_TEXTURE_GEN_T,osg::StateAttribute::ON);
     
237.         _stateset->setTextureMode(_shadowTextureUnit,GL_TEXTURE_GEN_R,osg::StateAttribute::ON);
     
238.         _stateset->setTextureMode(_shadowTextureUnit,GL_TEXTURE_GEN_Q,osg::StateAttribute::ON);
     
239.         
     
240.         _texgen = new osg::TexGen;
     
241.         
     
242.         // add Program, when empty of Shaders then we are using fixed functionality
     
243.         _program = new osg::Program;
     
244.         _stateset->setAttribute(_program.get());
     
245.         
     
246.         //shader
     
247.                 //osg::Shader* fragment_shader = new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource_noBaseTexture);
     
248.         osg::Shader* fragment_shader = osg::Shader::readShaderFile(osg::Shader::FRAGMENT,fragmentShaderSource_noBaseTexture);
     
249. 
     
250.         _program->addShader(fragment_shader);
     
251.         
     
252.         //_ambientBias(0.5f,0.5f),
     
253.         osg::Uniform* shadowTextureSampler = new osg::Uniform("osgShadow_shadowTexture",(int)_shadowTextureUnit);
     
254.         osg::Uniform* baseTextureSampler = new osg::Uniform("osgShadow_baseTexture",(int)_baseTextureUnit);
     
255.         
     
256.         osg::Vec2 ambientBias(0.5f,0.5f);
     
257.         osg::ref_ptr<osg::Uniform>  ambientBiasUniform = new osg::Uniform("osgShadow_ambientBias",ambientBias);
     
258.         
     
259.         _stateset->addUniform(shadowTextureSampler);
     
260.         _stateset->addUniform(ambientBiasUniform);
     
261.         _stateset->addUniform(baseTextureSampler);
     
262.         
     
263.         //fake image
     
264.         osg::Image* image = new osg::Image;
     
265.         // allocate the image data, noPixels x 1 x 1 with 4 rgba floats - equivilant to a Vec4!
     
266.         int noPixels = 1;
     
267.         image->allocateImage(noPixels,1,1,GL_RGBA,GL_FLOAT);
     
268.         image->setInternalTextureFormat(GL_RGBA);
     
269.         // fill in the image data.
     
270.         osg::Vec4* dataPtr = (osg::Vec4*)image->data();
     
271.         osg::Vec4 color(1,1,1,1);
     
272.         *dataPtr = color;
     
273.         // make fake texture
     
274.         osg::Texture2D* fakeTex = new osg::Texture2D;
     
275.         fakeTex->setWrap(osg::Texture2D::WRAP_S,osg::Texture2D::CLAMP_TO_EDGE);
     
276.         fakeTex->setWrap(osg::Texture2D::WRAP_T,osg::Texture2D::CLAMP_TO_EDGE);
     
277.         fakeTex->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR);
     
278.         fakeTex->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::LINEAR);
     
279.         fakeTex->setImage(image);
     
280.         // add fake texture
     
281.         _stateset->setTextureAttribute(_baseTextureUnit,fakeTex,osg::StateAttribute::ON);
     
282.         _stateset->setTextureMode(_baseTextureUnit,GL_TEXTURE_2D,osg::StateAttribute::ON);
     
283.         _stateset->setTextureMode(_baseTextureUnit,GL_TEXTURE_3D,osg::StateAttribute::OFF);
     
284.     }
     
285.    
     
286.         void update(osg::NodeVisitor &nv)
     
287.         {
     
288.                 _scene->osg::Group::traverse(nv);
     
289.         }
     
290.     void init()
     
291.     {
     
292.         initTexture();
     
293.         initRTTCamera();
     
294.         createStateSet();
     
295.         
     
296.         _dirty = false;
     
297.     }
     
298.    
     
299.     void setScene(osg::Group * scene){_scene = scene;}
     
300.    
     
301.     osg::ref_ptr<osg::Group> getScene(){return _scene;}
     
302. private:
     
303.     bool _dirty;
     
304.     osg::ref_ptr<osg::Texture2D>    _texture;
     
305.     osg::ref_ptr<osg::Camera>       _camera;
     
306.     osg::Vec2        _textureSize;
     
307.     osg::ref_ptr<osg::StateSet>        _stateset;
     
308.     unsigned int                    _baseTextureUnit;
     
309.     unsigned int                    _shadowTextureUnit;
     
310.     osg::ref_ptr<osg::TexGen>        _texgen;
     
311.     osg::ref_ptr<osg::Program>        _program;
     
312.     osg::ref_ptr<osg::Group>        _scene;
     
313.    
     
314. };
     
315. 
     
316. 
     
317. void CameraCullCallbackA::operator()(osg::Node*, osg::NodeVisitor* nv)
     
318. {
     
319.     __shadow->getScene()->osg::Group::traverse(*nv);
     
320. }
     
321. 
     
322. class myNode :public osg::Group
     
323. {
     
324.     public :
     
325.     myNode(shadow_X * s = nullptr){setNumChildrenRequiringUpdateTraversal(1); _shadow = s;}
     
326.     void traverse(osg::NodeVisitor& nv)
     
327.     {
     
328.         if(_shadow)
     
329.             _shadow->traverse(nv);
     
330.         else
     
331.             osg::Group::traverse(nv);
     
332.     }
     
333.     /** Resize any per context GLObject buffers to specified size. */
     
334.          void resizeGLObjectBuffers(unsigned int maxSize)
     
335.                 {
     
336.                         if (_shadow) _shadow->resizeGLObjectBuffers(maxSize);
     
337.                         Group::resizeGLObjectBuffers(maxSize);
     
338.                 }
     
339. 
     
340.         /** If State is non-zero, this function releases any associated OpenGL objects for
     
341.            * the specified graphics context. Otherwise, releases OpenGL objects
     
342.            * for all graphics contexts. */
     
343.          void releaseGLObjects(osg::State* state) const
     
344.                  {
     
345.                          if (_shadow) _shadow->releaseGLObjects(state);
     
346.                          Group::releaseGLObjects(state);
     
347.                  }
     
348. private:
     
349.     shadow_X* _shadow;
     
350. };
     
351. 
     
352. osg::Geode* createWoodA(osg::ref_ptr<osg::Group> parent)
     
353. {
     
354.     osg::ref_ptr<osg::Geode> geode = new osg::Geode();
     
355.     osg::Geometry* pointsGeom = new osg::Geometry();
     
356.    
     
357.     osg::Vec3Array* vertices = new osg::Vec3Array;
     
358.     vertices->push_back(osg::Vec3(10, 10, 0));
     
359.     vertices->push_back(osg::Vec3(-10,10, 0));
     
360.     vertices->push_back(osg::Vec3(-10, -10,0));
     
361.    
     
362.     vertices->push_back(osg::Vec3(-10, -10,0));
     
363.     vertices->push_back(osg::Vec3(10, -10,0));
     
364.     vertices->push_back(osg::Vec3(10, 10,0));
     
365.    
     
366.     pointsGeom->setVertexArray(vertices);
     
367.    
     
368.     osg::Vec4Array* colors = new osg::Vec4Array;
     
369.     colors->push_back(osg::Vec4(1.0f,1.0f,0.0f,1.0f));
     
370.     pointsGeom->setColorArray(colors, osg::Array::BIND_OVERALL);
     
371.    
     
372.    
     
373.     // set the normal in the same way color.
     
374.     /*osg::Vec3Array* normals = new osg::Vec3Array;
     
375.      normals->push_back(osg::Vec3(0.0f,-1.0f,0.0f));
     
376.      pointsGeom->setNormalArray(normals, osg::Array::BIND_OVERALL);*/
     
377.    
     
378.     pointsGeom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::TRIANGLES,0,vertices->size()));
     
379.     // add the points geometry to the geode.
     
380.     geode->addDrawable(pointsGeom);
     
381.    
     
382.     parent->addChild(geode);
     
383.    
     
384.     return geode.release();
     
385. }
     
386. 
     
387. osg::Geode * createLineA(osg::ref_ptr<osg::Group> parent)
     
388. {
     
389.         osg::ref_ptr<osg::Geode> geode = new osg::Geode();
     
390.     osg::Geometry* pointsGeom = new osg::Geometry();
     
391.    
     
392.     osg::Vec3Array* vertices = new osg::Vec3Array;
     
393.      
     
394.     vertices->push_back(eyePos);
     
395.     vertices->push_back(targetPos);
     
396.    
     
397.         osg::Vec4Array* colors = new osg::Vec4Array;
     
398.         colors->push_back(osg::Vec4(0.0f,1.0f,0.0f,1.0f));
     
399.         pointsGeom->setColorArray(colors, osg::Array::BIND_OVERALL);
     
400. 
     
401.     pointsGeom->setVertexArray(vertices);
     
402.    
     
403.     pointsGeom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINES,0,vertices->size()));
     
404.     // add the points geometry to the geode.
     
405.     geode->addDrawable(pointsGeom);
     
406.    
     
407.     parent->addChild(geode);
     
408.    
     
409.     return geode.release();
     
410. }
     
411. 
     
412. 
     
413. osg::Group* createModeA(osg::ref_ptr<osg::Group> parent)
     
414. {
     
415.    
     
416.     osg::ref_ptr<osg::Node> cow  = osgDB::readNodeFile("glider.osg");
     
417.     cow->setNodeMask(CastsShadowTraversalMask);
     
418.    
     
419.    
     
420.     osg::ref_ptr<osg::MatrixTransform > cowScale = new osg::MatrixTransform;
     
421.     osg::Matrix scale = osg::Matrix::scale(1,1,1);
     
422.     osg::Matrix tansla = osg::Matrix::translate(0.0,0.0,2.0);
     
423.     cowScale->setMatrix(tansla * scale);
     
424.     cowScale->addChild(cow);
     
425.    
     
426.     parent->addChild(cowScale);
     
427.    
     
428.     osg::ComputeBoundsVisitor cbbv;
     
429.     cowScale->accept(cbbv);
     
430.    
     
431.     osg::BoundingBox bb=cbbv.getBoundingBox();
     
432.    
     
433.     return cowScale.release();
     
434. }
     
435. 
     
436. osg::ref_ptr<osg::Node>createLightA()  
     
437. {  
     
438.    
     
439.     osg::ref_ptr<osg::Light>lt=new osg::Light;  
     
440.     lt->setLightNum(0);  
     
441.    
     
442.     //设置环境光的颜色  
     
443.     lt->setAmbient(osg::Vec4(1.0f,1.0f,1.0f,1.0f));
     
444.     lt->setPosition(osg::Vec4(eyePos,0));
     
445. 
     
446.     osg::ref_ptr<osg::LightSource>ls=new osg::LightSource();  
     
447.    
     
448.     ls->setLight(lt.get());  
     
449. 
     
450.    
     
451.     return ls.get();
     
452. }
     
453. 
     
454. int main()  
     
455. {  
     
456.    
     
457.     osg::ref_ptr<osgViewer::Viewer> viewer = new osgViewer::Viewer();  
     
458.     viewer->addEventHandler(new osgViewer::WindowSizeHandler);  
     
459.     //创建一个组节点  
     
460.    
     
461. 
     
462.     shadow_X * sh = new shadow_X();
     
463.      osg::ref_ptr<myNode> node = new myNode(sh);
     
464.      sh->setScene(node);
     
465.      
     
466.      osg::ref_ptr<osg::Geode> wood = createWoodA(node);
     
467.      osg::ref_ptr<osg::Group> cow = createModeA(node);
     
468.          createLineA(node);
     
469. 
     
470.   
     
471.     viewer->setSceneData(node);
     
472.     viewer->realize();  
     
473.     viewer->run();  
     
474.    
     
475.     return 0 ;  
     
476. }
     
477. 
     
478. 
     
479. 
     

复制代码