root/OpenSceneGraph/trunk/examples/osgshaderterrain/osgshaderterrain.cpp @ 6051

Revision 6051, 9.7 kB (checked in by robert, 7 years ago)

Added osg::FrameStamp::set/getSimulationTime().

Added setting of osg_SimulationTime and osg_DeltaSimulationTime to the uniforms set by SceneView?

Added frame(double simulationTime) and advance(double simulationTime) parameters to
osgViewer::SimpleViewer?, Vewer and CompositeViewer?.

Updated various examples and Nodes to use SimulationTime? where appropriate.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1#include <osg/AlphaFunc>
2#include <osg/Billboard>
3#include <osg/BlendFunc>
4#include <osg/Depth>
5#include <osg/Geode>
6#include <osg/Geometry>
7#include <osg/GL2Extensions>
8#include <osg/Material>
9#include <osg/Math>
10#include <osg/MatrixTransform>
11#include <osg/PolygonOffset>
12#include <osg/Program>
13#include <osg/Projection>
14#include <osg/Shader>
15#include <osg/ShapeDrawable>
16#include <osg/StateSet>
17#include <osg/Switch>
18#include <osg/Texture2D>
19#include <osg/Uniform>
20
21#include <osgDB/ReadFile>
22#include <osgDB/FileUtils>
23
24#include <osgUtil/IntersectVisitor>
25#include <osgUtil/SmoothingVisitor>
26
27#include <osgText/Text>
28
29#include <osgViewer/Viewer>
30
31#include <iostream>
32
33// for the grid data..
34#include "../osghangglide/terrain_coords.h"
35
36osg::Node* createScene()
37{
38    osg::Group* scene = new osg::Group;
39   
40    unsigned int numColumns = 38;
41    unsigned int numRows = 39;
42    unsigned int r;
43    unsigned int c;
44
45    osg::Vec3 origin(0.0f,0.0f,0.0f);
46    osg::Vec3 size(1000.0f,1000.0f,250.0f);
47    osg::Vec3 scaleDown(1.0f/size.x(),1.0f/size.y(),1.0f/size.z());
48
49    // ---------------------------------------
50    // Set up a StateSet to texture the objects
51    // ---------------------------------------
52    osg::StateSet* stateset = new osg::StateSet();
53
54
55    osg::Uniform* originUniform = new osg::Uniform("terrainOrigin",origin);
56    stateset->addUniform(originUniform);
57
58    osg::Uniform* sizeUniform = new osg::Uniform("terrainSize",size);
59    stateset->addUniform(sizeUniform);
60
61    osg::Uniform* scaleDownUniform = new osg::Uniform("terrainScaleDown",scaleDown);
62    stateset->addUniform(scaleDownUniform);
63
64    osg::Uniform* terrainTextureSampler = new osg::Uniform("terrainTexture",0);
65    stateset->addUniform(terrainTextureSampler);
66
67    osg::Uniform* baseTextureSampler = new osg::Uniform("baseTexture",1);
68    stateset->addUniform(baseTextureSampler);
69
70    osg::Uniform* treeTextureSampler = new osg::Uniform("treeTexture",1);
71    stateset->addUniform(treeTextureSampler);
72
73
74    // compute z range of z values of grid data so we can scale it.
75    float min_z = FLT_MAX;
76    float max_z = -FLT_MAX;
77    for(r=0;r<numRows;++r)
78    {
79        for(c=0;c<numColumns;++c)
80        {
81            min_z = osg::minimum(min_z,vertex[r+c*numRows][2]);
82            max_z = osg::maximum(max_z,vertex[r+c*numRows][2]);
83        }
84    }
85       
86    float scale_z = size.z()/(max_z-min_z);
87
88    osg::Image* terrainImage = new osg::Image;
89    terrainImage->allocateImage(numColumns,numRows,1,GL_LUMINANCE, GL_FLOAT);
90    terrainImage->setInternalTextureFormat(GL_LUMINANCE_FLOAT32_ATI);
91    for(r=0;r<numRows;++r)
92    {
93        for(c=0;c<numColumns;++c)
94        {
95            *((float*)(terrainImage->data(c,r))) = (vertex[r+c*numRows][2]-min_z)*scale_z;
96        }
97    }
98   
99    osg::Texture2D* terrainTexture = new osg::Texture2D;
100    terrainTexture->setImage(terrainImage);
101    terrainTexture->setFilter(osg::Texture2D::MIN_FILTER, osg::Texture2D::NEAREST);
102    terrainTexture->setFilter(osg::Texture2D::MAG_FILTER, osg::Texture2D::NEAREST);
103    terrainTexture->setResizeNonPowerOfTwoHint(false);
104    stateset->setTextureAttributeAndModes(0,terrainTexture,osg::StateAttribute::ON);
105
106
107    osg::Image* image = osgDB::readImageFile("Images/lz.rgb");
108    if (image)
109    {
110        osg::Texture2D* texture = new osg::Texture2D;
111       
112        texture->setImage(image);
113        stateset->setTextureAttributeAndModes(1,texture,osg::StateAttribute::ON);
114    }
115
116    {   
117        std::cout<<"Creating terrain...";
118
119        osg::Geode* geode = new osg::Geode();
120        geode->setStateSet( stateset );
121
122
123        {
124            osg::Program* program = new osg::Program;
125            stateset->setAttribute(program);
126
127#if 1
128            // use inline shaders
129           
130            ///////////////////////////////////////////////////////////////////
131            // vertex shader using just Vec4 coefficients
132            char vertexShaderSource[] =
133               "uniform sampler2D terrainTexture;\n"
134               "uniform vec3 terrainOrigin;\n"
135               "uniform vec3 terrainScaleDown;\n"
136               "\n"
137               "varying vec2 texcoord;\n"
138               "\n"
139               "void main(void)\n"
140               "{\n"
141               "    texcoord = gl_Vertex.xy - terrainOrigin.xy;\n"
142               "    texcoord.x *= terrainScaleDown.x;\n"
143               "    texcoord.y *= terrainScaleDown.y;\n"
144               "\n"
145               "    vec4 position;\n"
146               "    position.x = gl_Vertex.x;\n"
147               "    position.y = gl_Vertex.y;\n"
148               "    position.z = texture2D(terrainTexture, texcoord).r;\n"
149               "    position.w = 1.0;\n"
150               " \n"
151               "    gl_Position     = gl_ModelViewProjectionMatrix * position;\n"
152                "   gl_FrontColor = vec4(1.0,1.0,1.0,1.0);\n"
153               "}\n";
154
155            //////////////////////////////////////////////////////////////////
156            // fragment shader
157            //
158            char fragmentShaderSource[] =
159                "uniform sampler2D baseTexture; \n"
160                "varying vec2 texcoord;\n"
161                "\n"
162                "void main(void) \n"
163                "{\n"
164                "    gl_FragColor = texture2D( baseTexture, texcoord); \n"
165                "}\n";
166
167            program->addShader(new osg::Shader(osg::Shader::VERTEX, vertexShaderSource));
168            program->addShader(new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource));
169           
170#else
171
172            // get shaders from source
173            program->addShader(osg::Shader::readShaderFile(osg::Shader::VERTEX, osgDB::findDataFile("shaders/terrain.vert")));
174            program->addShader(osg::Shader::readShaderFile(osg::Shader::FRAGMENT, osgDB::findDataFile("shaders/terrain.frag")));
175
176#endif
177
178            // get shaders from source
179        }
180
181
182        {
183            osg::Geometry* geometry = new osg::Geometry;
184
185            osg::Vec3Array& v = *(new osg::Vec3Array(numColumns*numRows));
186            osg::Vec4ubArray& color = *(new osg::Vec4ubArray(1));
187
188            color[0].set(255,255,255,255);
189
190            float rowCoordDelta = size.y()/(float)(numRows-1);
191            float columnCoordDelta = size.x()/(float)(numColumns-1);
192
193            float rowTexDelta = 1.0f/(float)(numRows-1);
194            float columnTexDelta = 1.0f/(float)(numColumns-1);
195
196            osg::Vec3 pos = origin;
197            osg::Vec2 tex(0.0f,0.0f);
198            int vi=0;
199            for(r=0;r<numRows;++r)
200            {
201                pos.x() = origin.x();
202                tex.x() = 0.0f;
203                for(c=0;c<numColumns;++c)
204                {
205                    v[vi].set(pos.x(),pos.y(),pos.z());
206                    pos.x()+=columnCoordDelta;
207                    tex.x()+=columnTexDelta;
208                    ++vi;
209                }
210                pos.y() += rowCoordDelta;
211                tex.y() += rowTexDelta;
212            }
213
214            geometry->setVertexArray(&v);
215            geometry->setColorArray(&color);
216            geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
217
218            for(r=0;r<numRows-1;++r)
219            {
220                osg::DrawElementsUShort& drawElements = *(new osg::DrawElementsUShort(GL_QUAD_STRIP,2*numColumns));
221                geometry->addPrimitiveSet(&drawElements);
222                int ei=0;
223                for(c=0;c<numColumns;++c)
224                {
225                    drawElements[ei++] = (r+1)*numColumns+c;
226                    drawElements[ei++] = (r)*numColumns+c;
227                }
228            }
229           
230            geometry->setInitialBound(osg::BoundingBox(origin, origin+size));
231
232            geode->addDrawable(geometry);
233
234            scene->addChild(geode);
235        }
236    }
237       
238    std::cout<<"done."<<std::endl;
239   
240    return scene;
241}
242
243class TestSupportOperation: public osg::GraphicsOperation
244{
245public:
246
247    TestSupportOperation():
248        osg::GraphicsOperation("TestSupportOperation",false),
249        _supported(true),
250        _errorMessage() {}
251
252    virtual void operator () (osg::GraphicsContext* gc)
253    {
254        osg::notify(osg::NOTICE)<<"Not called"<<std::endl;
255   
256        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
257
258        unsigned int contextID = gc->getState()->getContextID();
259        osg::GL2Extensions* gl2ext = osg::GL2Extensions::Get(contextID,true);
260        if( gl2ext )
261        {
262            if( !gl2ext->isGlslSupported() )
263            {
264                _supported = false;
265                _errorMessage = "ERROR: GLSL not supported by OpenGL driver.";
266            }
267
268            GLint numVertexTexUnits = 0;
269            glGetIntegerv( GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &numVertexTexUnits );
270            if( numVertexTexUnits <= 0 )
271            {
272                _supported = false;
273                _errorMessage = "ERROR: vertex texturing not supported by OpenGL driver.";
274            }
275        }
276
277        _supported = false;
278        _errorMessage = "ERROR: Pllalalal.";
279
280    }
281       
282    OpenThreads::Mutex  _mutex;
283    bool                _supported;
284    std::string         _errorMessage;
285};
286
287int main(int, char **)
288{
289    // construct the viewer.
290    osgViewer::Viewer viewer;
291
292    osg::Node* node = createScene();
293
294    // add model to viewer.
295    viewer.setSceneData( node );
296
297    viewer.setUpViewAcrossAllScreens();
298   
299    osg::ref_ptr<TestSupportOperation> testSupportOperation = new TestSupportOperation;
300
301    osgViewer::Viewer::Windows windows;
302    viewer.getWindows(windows);
303    for(osgViewer::Viewer::Windows::iterator itr = windows.begin();
304        itr != windows.end();
305        ++itr)
306    {
307        (*itr)->add(testSupportOperation.get());
308    }
309
310    // create the windows and run the threads.
311    viewer.realize();
312   
313    if (!testSupportOperation->_supported)
314    {
315        osg::notify(osg::WARN)<<testSupportOperation->_errorMessage<<std::endl;
316
317        return 1;
318    }
319
320    return viewer.run();
321}
Note: See TracBrowser for help on using the browser.