Changeset 9141 for OpenSceneGraph/trunk/examples/osgmemorytest/osgmemorytest.cpp

Timestamp:

11/11/08 13:50:51 (5 years ago)

Author:

robert

Message:

Added support for fbo testing.

Files:

• OpenSceneGraph/trunk/examples/osgmemorytest/osgmemorytest.cpp (modified) (16 diffs)

OpenSceneGraph/trunk/examples/osgmemorytest/osgmemorytest.cpp

@@ -30 +30 @@
 };
 
+class GLObject : public osg::Referenced
+{
+    public:
+        virtual void apply(osg::State& state) = 0;
+};
+
 class GLMemoryTest : public MemoryTest
 {
     public:
-        virtual void allocate(osg::State& state) = 0;
-};
-
-class ContextTest : public MemoryTest
-{
-    public:
-        virtual osg::GraphicsContext* allocate() = 0;
+        virtual GLObject* allocate() = 0;
 };
 
 /////////////////////////////////////////////////////////////////////////
 //
-// PBuffer test
-class PBufferTest : public ContextTest
-{
-    public:
-        PBufferTest(int width, int height):
+// Context test
+class ContextTest : public MemoryTest
+{
+    public:
+        ContextTest(int width, int height, bool pbuffer):
             _width(width),
-            _height(height) {}
-        
-        virtual bool requiresContext() { return false; }
-        virtual osg::GraphicsContext* allocate()
-        {
-            osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
-            traits->width = _width;
-            traits->height = _height;
-            traits->pbuffer = true;
-            
-            osg::ref_ptr<osg::GraphicsContext> pbuffer = osg::GraphicsContext::createGraphicsContext(traits.get());
-            if (pbuffer.valid()) 
-            {
-                if (pbuffer->realize())
-                {
-                    pbuffer->makeCurrent();
-                    pbuffer->releaseContext();
-
-                    return pbuffer.release();
-                }
-                else
-                {
-                    throw "Failed to realize Pixelbuffer";
-                }
-            }
-            else
-            {
-                throw "Failed to created PixelBuffer";
-            }
-            return 0;
-        }
-        
-
-    protected:
-    
-        int     _width;
-        int     _height;
-};
-
-/////////////////////////////////////////////////////////////////////////
-//
-// Window test
-class WindowTest : public ContextTest
-{
-    public:
-        WindowTest(int width, int height):
-            _width(width),
-            _height(height) {}
-        
-        virtual bool requiresContext() { return false; }
+            _height(height),
+            _pbuffer(pbuffer) {}
+        
         virtual osg::GraphicsContext* allocate()
         {
@@ -106 +59 @@
             traits->height = _height;
             traits->windowDecoration = true;
+            traits->pbuffer = _pbuffer;
             
             osg::ref_ptr<osg::GraphicsContext> window = osg::GraphicsContext::createGraphicsContext(traits.get());
@@ -112 +66 @@
                 if (window->realize())
                 {
-                    window->makeCurrent();
-                    window->releaseContext();
-
                     return window.release();
                 }
                 else
                 {
-                    throw "Failed to realize GraphicsWindow";
+                    if (_pbuffer) throw "Failed to realize PixelBuffer";
+                    else  throw "Failed to realize GraphicsWindow";
                 }
             }
             else
             {
-                throw "Failed to created GraphicsWindow";
+                if (_pbuffer) throw "Failed to create PixelBuffer";
+                else  throw "Failed to create GraphicsWindow";
             }
             return 0;
@@ -134 +87 @@
         int     _width;
         int     _height;
-};
-
+        bool    _pbuffer;
+};
+
+////////////////////////////////////////////////////////////////////////
+//
+// Wrap StateAttribute
+class StateAttributeObject : public GLObject
+{
+    public:
+    
+        StateAttributeObject(osg::StateAttribute* sa): _attribute(sa) {}
+        
+        void apply(osg::State& state)
+        {
+            _attribute->apply(state);
+            
+            if (state.checkGLErrors(_attribute.get()))
+            {
+                throw "OpenGL error";
+            }
+        }
+        
+        osg::ref_ptr<osg::StateAttribute> _attribute;
+};
 
 /////////////////////////////////////////////////////////////////////////
 //
-// Window test
+// Texture test
 class TextureTest : public GLMemoryTest
 {
     public:
+
         TextureTest(int width=1, int height=1, int depth=1):
             _width(width),
@@ -148 +124 @@
             _depth(depth) {}
         
-        virtual bool requiresContext() { return true; }
-        
-        virtual void allocate(osg::State& state)
+        virtual GLObject* allocate()
         {
             if (_depth>1)
@@ -159 +133 @@
                 osg::ref_ptr<osg::Texture3D> texture = new osg::Texture3D;
                 texture->setImage(image.get());
-                
-                texture->apply(state);
-
-                _textures.push_back(texture.get());
-                
+                texture->setResizeNonPowerOfTwoHint(false);
+                
+                return new StateAttributeObject(texture.get());
             }
             if (_height>1)
@@ -172 +144 @@
                 osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D;
                 texture->setImage(image.get());
-                
-                texture->apply(state);
-
-                _textures.push_back(texture.get());
+                texture->setResizeNonPowerOfTwoHint(false);
+                
+                return new StateAttributeObject(texture.get());
             }
             if (_width>1)
@@ -184 +155 @@
                 osg::ref_ptr<osg::Texture1D> texture = new osg::Texture1D;
                 texture->setImage(image.get());
-                
-                texture->apply(state);
-
-                _textures.push_back(texture.get());
+                texture->setResizeNonPowerOfTwoHint(false);
+                
+                return new StateAttributeObject(texture.get());
             }
             else
             {
-                throw "Invalid texture size of 0,0,0.";
-            }
-            
+                throw "Invalid texture size of 0,0,0";
+            }
+            return 0;            
         }
         
@@ -199 +169 @@
     protected:
     
-        virtual ~TextureTest()
-        {
-        }
-        
-        typedef std::list< osg::ref_ptr<osg::Texture> > Textures;
-        Textures _textures;
         int     _width;
         int     _height;
@@ -210 +174 @@
 };
 
+/////////////////////////////////////////////////////////////////////////
+//
+// Texture test
+class FboTest : public GLMemoryTest
+{
+    public:
+
+        FboTest(int width=1024, int height=1024, int depth=2):
+            _width(width),
+            _height(height),
+            _depth(depth) {}
+        
+        virtual GLObject* allocate()
+        {
+            osg::ref_ptr<osg::FrameBufferObject> fbo = new osg::FrameBufferObject;
+
+            if (_depth>=1) fbo->setAttachment(osg::Camera::COLOR_BUFFER, osg::FrameBufferAttachment(new osg::RenderBuffer(_width, _height, GL_RGBA)));
+            if (_depth>=2) fbo->setAttachment(osg::Camera::DEPTH_BUFFER, osg::FrameBufferAttachment(new osg::RenderBuffer(_width, _height, GL_DEPTH_COMPONENT24)));
+
+            return new StateAttributeObject(fbo.get());
+        }
+        
+
+    protected:
+    
+        int     _width;
+        int     _height;
+        int     _depth;
+};
+
 int main( int argc, char **argv )
 {
@@ -218 +212 @@
     
     int width, height, depth;
-    while(arguments.read("--pbuffer",width,height)) { tests.push_back(new PBufferTest(width,height)); }
-    while(arguments.read("--pbuffer")) { tests.push_back(new PBufferTest(1024,1024)); }
-
-    while(arguments.read("--window",width,height)) { tests.push_back(new WindowTest(width,height)); }
-    while(arguments.read("--window")) { tests.push_back(new WindowTest(1024,1024)); }
+    while(arguments.read("--pbuffer",width,height)) { tests.push_back(new ContextTest(width, height, true)); }
+    while(arguments.read("--pbuffer")) { tests.push_back(new ContextTest(512, 512, true)); }
+
+    while(arguments.read("--window",width,height)) { tests.push_back(new ContextTest(width, height, false)); }
+    while(arguments.read("--window")) { tests.push_back(new ContextTest(512,512, false)); }
 
     while(arguments.read("--texture",width,height,depth)) { tests.push_back(new TextureTest(width,height,depth)); }
@@ -228 +222 @@
     while(arguments.read("--texture",width)) { tests.push_back(new TextureTest(width,1,1)); }
 
-    int maxNumContextIterations = 1000;
+    while(arguments.read("--fbo",width,height,depth)) { tests.push_back(new FboTest(width,height,depth)); }
+    while(arguments.read("--fbo",width,height)) { tests.push_back(new FboTest(width,height,2)); }
+    while(arguments.read("--fbo")) { tests.push_back(new FboTest(1024,1024,2)); }
+
+    int maxNumContextIterations = 1;
     while(arguments.read("-c",maxNumContextIterations)) {}
 
@@ -236 +234 @@
     typedef std::list< osg::ref_ptr<GLMemoryTest> > GLMemoryTests;
     typedef std::list< osg::ref_ptr<ContextTest> > ContextTests;
-
 
     
@@ -258 +255 @@
 
     typedef std::list< osg::ref_ptr<osg::GraphicsContext> > Contexts;
+    typedef std::list< osg::ref_ptr<GLObject> > GLObjects;
     Contexts allocatedContexts;
+    GLObjects glObjects;
 
     int numContextIterations = 0;
+    int numGLObjectIterations = 0;
+    int numGLObjectsApplied = 0;
     try
     {
+        for(; numGLObjectIterations<maxNumGLIterations; ++numGLObjectIterations)
+        {    
+            for(GLMemoryTests::iterator itr = glMemoryTests.begin();
+                itr != glMemoryTests.end();
+                ++itr)
+            {
+                osg::ref_ptr<GLObject> glObject = (*itr)->allocate();
+                if (glObject.valid()) glObjects.push_back(glObject.get());
+            }
+        }
+        
         for(;numContextIterations<maxNumContextIterations; ++numContextIterations)
         {
@@ -273 +285 @@
                 if (context.valid())
                 {
+                    allocatedContexts.push_back(context);
+
                     context->makeCurrent();
+                    
+                    for(GLObjects::iterator gitr = glObjects.begin();
+                        gitr != glObjects.end();
+                        ++gitr)
+                    {
+                        (*gitr)->apply(*(context->getState()));
+                        ++numGLObjectsApplied;
+                    }
+                    
                     context->releaseContext();
-                    
-                    allocatedContexts.push_back(context);
                 }
             }
@@ -283 +304 @@
     catch(const char* errorString)
     {
-        printf("Exception caught, number of iterations completed = %i, error = %s\n",numContextIterations, errorString);
+        printf("Exception caught, contexts completed = %i, gl objects successfully applied =%i, error = %s\n",numContextIterations, numGLObjectsApplied, errorString);
         return 1;
     }
     catch(...)
     {
-        printf("Exception caught, number of iterations completed = %i\n",numContextIterations);
+        printf("Exception caught, contexts completed = %i, gl objects successfully applied =%i\n",numContextIterations, numGLObjectsApplied);
         return 1;
     }
 
-    printf("Successful completion, number of iterations completed = %i\n",numContextIterations);
+    printf("Successful completion, contexts created = %i, gl objects applied =%i\n",numContextIterations, numGLObjectsApplied);
     
     return 0;