Changeset 5863 for OpenSceneGraph/trunk/examples/osgparametric/osgparametric.cpp

Timestamp:

01/01/07 19:20:10 (6 years ago)

Author:

robert

Message:

Various work on osgViewer library, including warp point and graphics window resize support

Files:

• OpenSceneGraph/trunk/examples/osgparametric/osgparametric.cpp (modified) (10 diffs)

OpenSceneGraph/trunk/examples/osgparametric/osgparametric.cpp

@@ -12 +12 @@
 
 #include <osgUtil/Optimizer>
+#include <osgUtil/TriStripVisitor>
 
 #include <osgProducer/Viewer>
@@ -58 +59 @@
     "    gl_TexCoord[0] = gl_Vertex; \n"
     "    vec4 vert = gl_Vertex; \n"
-    "    vert.z = texture2D( vertexTexture, gl_TexCoord[0].xy).x*0.0001; \n"
+    "    vert.z = texture2D( vertexTexture, gl_TexCoord[0].xy).x*0.1; \n"
     "    gl_Position = gl_ModelViewProjectionMatrix * vert;\n"
     "}\n";
 
+//////////////////////////////////////////////////////////////////
+// vertex shader using texture read
+char vertexShaderSource_texture2[] = 
+    "uniform sampler2D vertexTexture; \n"
+    "uniform sampler2D vertexTexture2; \n"
+    "uniform float osg_FrameTime;\n"
+    "\n"
+    "void main(void) \n"
+    "{ \n"
+    "\n"
+    "    gl_TexCoord[0] = gl_Vertex; \n"
+    "    vec4 vert = gl_Vertex; \n"
+    "    float r = 1.0 + 0.5 * sin(osg_FrameTime);\n"
+    "    vert.z = (texture2D( vertexTexture, gl_TexCoord[0].xy).x * (1-r) + texture2D( vertexTexture2, gl_TexCoord[0].xy).x * r)*0.1; \n"
+    "    gl_Position = gl_ModelViewProjectionMatrix * vert;\n"
+    "}\n";
 
 //////////////////////////////////////////////////////////////////
@@ -74 +91 @@
     "}\n";
 
-
+#if 0
+char fragmentShaderNormalSource[] = 
+    "uniform sampler2D baseTexture; \n"
+    "uniform sampler2D vertexTexture; \n"
+    "\n"
+    "void main(void) \n"
+    "{ \n"
+    "    const float dx = 0.0010;  \n"
+    "    const float dy = 0.0010;  \n"
+    "    float dz_dx = texture2D( vertexTexture, gl_TexCoord[0].xy + vec2(dx,0.0)).x - texture2D( vertexTexture, gl_TexCoord[0].xy + vec2(-dx,0.0)).x; \n"
+    "    float dz_dy = texture2D( vertexTexture, gl_TexCoord[0].xy + vec2(0.0,dy)).x - texture2D( vertexTexture, gl_TexCoord[0].xy + vec2(0.0,-dy)).x; \n"
+    "    vec3 normal = normalize(vec3(-dz_dx, -dz_dy, dx*50));\n"
+    " \n"
+    "    gl_FragColor = vec4(normal.z,normal.z,normal.z,1.0); \n"
+    "}\n";
+#else
+char fragmentShaderNormalSource[] = 
+    "uniform sampler2D baseTexture; \n"
+    "uniform sampler2D vertexTexture; \n"
+    "\n"
+    "void main(void) \n"
+    "{ \n"
+    "    vec3 normal = normalize(texture2D( baseTexture, gl_TexCoord[0].xy).xyz);\n"
+    " \n"
+    "    gl_FragColor = vec4(normal.z,normal.z,normal.z,1.0); \n"
+    "}\n";
+#endif
 
 class UniformVarying : public osg::Uniform::Callback
@@ -86 +129 @@
 };
 
-osg::Node* createModel(const std::string& shader, const std::string& textureFileName, const std::string& terrainFileName)
+osg::Node* createModel(const std::string& shader, const std::string& textureFileName, const std::string& terrainFileName, const std::string& terrainFileName2, unsigned int cacheSize, unsigned int maxSize, bool joinStrips, const std::string& mesh)
 {
     osg::Geode* geode = new osg::Geode;
@@ -132 +175 @@
         else if (shader=="texture")
         {
-            osg::Shader* vertex_shader = new osg::Shader(osg::Shader::VERTEX, vertexShaderSource_texture);
-            program->addShader(vertex_shader);
 
             osg::Image* image = 0;
@@ -167 +208 @@
             vertexTexture->setFilter(osg::Texture::MIN_FILTER,osg::Texture::NEAREST);
             vertexTexture->setFilter(osg::Texture::MAG_FILTER,osg::Texture::NEAREST);
+            
             vertexTexture->setInternalFormat(GL_LUMINANCE_FLOAT32_ATI);
+            
+            vertexTexture->setResizeNonPowerOfTwoHint(false);
             stateset->setTextureAttributeAndModes(1,vertexTexture);
 
@@ -173 +217 @@
             stateset->addUniform(vertexTextureSampler);
 
-        }
-
-        osg::Shader* fragment_shader = new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource);
-        program->addShader(fragment_shader);
-
+            if (!terrainFileName2.empty())
+            {
+                osg::Image* image2 = osgDB::readImageFile(terrainFileName2);
+                osg::Texture2D* vertexTexture2 = new osg::Texture2D(image2);
+
+
+                vertexTexture2->setFilter(osg::Texture::MIN_FILTER,osg::Texture::NEAREST);
+                vertexTexture2->setFilter(osg::Texture::MAG_FILTER,osg::Texture::NEAREST);
+
+                vertexTexture2->setInternalFormat(GL_LUMINANCE_FLOAT32_ATI);
+
+                vertexTexture2->setResizeNonPowerOfTwoHint(false);
+                stateset->setTextureAttributeAndModes(2,vertexTexture2);
+
+                osg::Uniform* vertexTextureSampler2 = new osg::Uniform("vertexTexture2",2);
+                stateset->addUniform(vertexTextureSampler2);
+
+            }
+
+        }
+
+        if (terrainFileName2.empty())
+        {
+            osg::Shader* fragment_shader = new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderNormalSource);
+            program->addShader(fragment_shader);
+
+            osg::Shader* vertex_shader = new osg::Shader(osg::Shader::VERTEX, vertexShaderSource_texture);
+            program->addShader(vertex_shader);
+        }
+        else
+        {
+
+            osg::Shader* fragment_shader = new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource);
+            program->addShader(fragment_shader);
+
+            osg::Shader* vertex_shader = new osg::Shader(osg::Shader::VERTEX, vertexShaderSource_texture2);
+            program->addShader(vertex_shader);
+        }
+        
         osg::Texture2D* texture = new osg::Texture2D(osgDB::readImageFile(textureFileName));
         stateset->setTextureAttributeAndModes(0,texture);
@@ -210 +288 @@
     geom->setVertexArray(vertices);
 
-    for(iy=0; iy<num_y-1; ++iy)
-    {
-        unsigned int element_no = 0;
-        osg::DrawElementsUInt* elements = new osg::DrawElementsUInt(GL_TRIANGLE_STRIP, num_x*2);
-        unsigned int index = iy * num_x;
-        for(unsigned int ix = 0; ix<num_x; ++ix)
-        {
-            (*elements)[element_no++] = index + num_x;
-            (*elements)[element_no++] = index++;
-        }
-        geom->addPrimitiveSet(elements);    
-    }
-    
-    // geom->setUseVertexBufferObjects(true);
+    unsigned int totalIndices = 0;
+    if (mesh=="triangles" || mesh=="tristrip")
+    {
+        if (cacheSize)
+        {
+            unsigned int index=0;
+            osg::DrawElementsUInt* elements = new osg::DrawElementsUInt(GL_TRIANGLES);
+            geom->addPrimitiveSet(elements);    
+            elements->dirty();
+            
+            for(unsigned int is=0; is<num_x; is += cacheSize-1)
+            {
+            
+                for(iy=0; iy<num_y-1; ++iy)
+                {
+                    unsigned int num_in_stripe = osg::minimum(cacheSize, num_x-is);
+                    
+                    bool rightToLeft = true;
+
+                    if (elements->size() > maxSize)
+                    {
+                        osg::notify(osg::NOTICE)<<"elements->size() = "<<elements->size()<<std::endl;
+                        totalIndices += elements->size();
+
+                        index=0;
+                        elements = new osg::DrawElementsUInt(GL_TRIANGLES);
+                        geom->addPrimitiveSet(elements);    
+                        elements->dirty();
+
+                    }
+
+                    if (rightToLeft)
+                    {
+
+                        index = iy * num_x + is;
+
+                        for(unsigned int ix = 0; ix<num_in_stripe-1; ++ix)
+                        {
+                            (*elements).push_back(index + num_x);
+                            (*elements).push_back(index);
+                            (*elements).push_back(index+1);
+
+                            (*elements).push_back(index + num_x);
+                            (*elements).push_back(index+1);
+                            (*elements).push_back(index + num_x + 1);
+
+                            ++index;
+                        }
+                    }
+                    else
+                    {
+                        index = iy * num_x + is + (num_x-2);
+
+                        for(unsigned int ix = 0; ix<num_in_stripe-1; ++ix)
+                        {
+                            (*elements).push_back(index + num_x);
+                            (*elements).push_back(index);
+                            (*elements).push_back(index+1);
+
+                            (*elements).push_back(index + num_x);
+                            (*elements).push_back(index+1);
+                            (*elements).push_back(index + num_x + 1);
+
+                            --index;
+                        }
+                    }
+                    
+                    rightToLeft = !rightToLeft;                    
+                    
+                }
+                
+            }
+            totalIndices += elements->size();
+            osg::notify(osg::NOTICE)<<"elements->size() = "<<elements->size()<<std::endl;
+        }
+        else
+        {
+            osg::DrawElementsUInt* elements = new osg::DrawElementsUInt(GL_TRIANGLES, (num_x-1)*(num_y-1)*6);
+            elements->dirty();
+            unsigned int element_no = 0;
+            for(iy=0; iy<num_y-1; ++iy)
+            {
+                unsigned int index = iy * num_x;
+                for(unsigned int ix = 0; ix<num_x-1; ++ix)
+                {
+                    (*elements)[element_no++] = index + num_x;
+                    (*elements)[element_no++] = index;
+                    (*elements)[element_no++] = index+1;
+
+                    (*elements)[element_no++] = index + num_x;
+                    (*elements)[element_no++] = index+1;
+                    (*elements)[element_no++] = index + num_x + 1;
+                    
+                    ++index;
+                }
+            }
+            geom->addPrimitiveSet(elements);    
+            osg::notify(osg::NOTICE)<<"elements->size() = "<<elements->size()<<std::endl;
+        }
+    }
+    else
+    {
+    
+        if (cacheSize)
+        {
+            bool needToJoin = false;
+            unsigned int index=0;
+            osg::DrawElementsUInt* elements = new osg::DrawElementsUInt(GL_TRIANGLE_STRIP);
+            geom->addPrimitiveSet(elements);    
+            elements->dirty();
+
+            for(unsigned int is=0; is<num_x; is += cacheSize-1)
+            {
+            
+                for(iy=0; iy<num_y-1; ++iy)
+                {
+                    unsigned int num_in_stripe = osg::minimum(cacheSize, num_x-is);
+                    
+                    bool rightToLeft = true;
+
+                    if (elements->size() > maxSize)
+                    {
+                        osg::notify(osg::NOTICE)<<"elements->size() = "<<elements->size()<<std::endl;
+
+                        totalIndices += elements->size();
+
+                        needToJoin = false;
+                        index=0;
+                        elements = new osg::DrawElementsUInt(GL_TRIANGLE_STRIP);
+                        geom->addPrimitiveSet(elements);    
+                        elements->dirty();
+
+                    }
+
+                    if (needToJoin) (*elements).push_back(elements->back());
+                    
+                    if (rightToLeft)
+                    {
+
+                        index = iy * num_x + is;
+
+                        if (needToJoin) (*elements).push_back(index + num_x);
+
+                        for(unsigned int ix = 0; ix<num_in_stripe; ++ix)
+                        {
+                            (*elements).push_back(index + num_x);
+                            (*elements).push_back(index++);
+                        }
+                    }
+                    else
+                    {
+                        index = iy * num_x + is + (num_x-1);
+
+                        if (needToJoin) (*elements).push_back(index);
+
+                        for(unsigned int ix = 0; ix<num_in_stripe; ++ix)
+                        {
+                            (*elements).push_back(index);
+                            (*elements).push_back(index-- + num_x);
+                        }
+                    }
+                    
+                    rightToLeft = !rightToLeft;                    
+                    
+                    needToJoin = true;
+                }
+                
+            }
+            totalIndices += elements->size();
+        }
+        else
+        {
+            osg::DrawElementsUInt* elements = new osg::DrawElementsUInt(GL_TRIANGLE_STRIP);
+            elements->dirty();
+            geom->addPrimitiveSet(elements);    
+            bool needToJoin = false;
+            unsigned int index=0;
+            for(iy=0; iy<num_y-1; ++iy)
+            {
+
+                if (needToJoin) (*elements).push_back(index-1);
+
+                index = iy * num_x;
+
+                if (needToJoin) (*elements).push_back(index + num_x);
+
+                for(unsigned int ix = 0; ix<num_x; ++ix)
+                {
+                    (*elements).push_back(index + num_x);
+                    (*elements).push_back(index++);
+                }
+                needToJoin = true;
+
+            }
+        }
+    }
+
+    osg::notify(osg::NOTICE)<<"totalIndices = "<<totalIndices<<std::endl;
+
+    if (mesh=="tristrip")
+    {   osgUtil::TriStripVisitor stripper;
+        stripper.stripify(*geom);
+    }
+
+#if 0
+    geom->setUseVertexBufferObjects(true);
+#else
+    geom->setUseVertexBufferObjects(false);
+#endif
 
     return geode;
@@ -253 +526 @@
     while(arguments.read("-d",terrainFileName)) {}
 
+    std::string terrainFileName2("");
+    while(arguments.read("-d2",terrainFileName2)) {}
+
+    unsigned int cacheSize = 0;
+    while(arguments.read("--cache",cacheSize)) {}
+
+    unsigned int maxSize = 2048;
+    while(arguments.read("--max",maxSize)) {}
+
+    std::string mesh("strip");
+    while(arguments.read("--mesh",mesh)) {}
+
+    bool joinStrips = false;
+    while(arguments.read("--join")) { joinStrips = true; }
+
     // get details on keyboard and mouse bindings used by the viewer.
     viewer.getUsage(*arguments.getApplicationUsage());
@@ -274 +562 @@
 
     // load the nodes from the commandline arguments.
-    osg::Node* model = createModel(shader,textureFileName,terrainFileName);
+    osg::Node* model = createModel(shader,textureFileName,terrainFileName,terrainFileName2, cacheSize, maxSize, joinStrips,mesh);
     if (!model)
     {