root/OpenSceneGraph/trunk/examples/osgmemorytest/osgmemorytest.cpp @ 9141

Revision 9141, 10.4 kB (checked in by robert, 6 years ago)

Added support for fbo testing.

Line 
1/* OpenSceneGraph example, osganimate.
2*
3*  Permission is hereby granted, free of charge, to any person obtaining a copy
4*  of this software and associated documentation files (the "Software"), to deal
5*  in the Software without restriction, including without limitation the rights
6*  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7*  copies of the Software, and to permit persons to whom the Software is
8*  furnished to do so, subject to the following conditions:
9*
10*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
11*  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12*  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
13*  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
14*  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
15*  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
16*  THE SOFTWARE.
17*/
18
19#include <osg/Notify>
20#include <osg/ArgumentParser>
21#include <osg/Texture1D>
22#include <osg/Texture2D>
23#include <osg/Texture3D>
24
25#include <osgViewer/Viewer>
26
27class MemoryTest : public osg::Referenced
28{
29    public:
30};
31
32class GLObject : public osg::Referenced
33{
34    public:
35        virtual void apply(osg::State& state) = 0;
36};
37
38class GLMemoryTest : public MemoryTest
39{
40    public:
41        virtual GLObject* allocate() = 0;
42};
43
44/////////////////////////////////////////////////////////////////////////
45//
46// Context test
47class ContextTest : public MemoryTest
48{
49    public:
50        ContextTest(int width, int height, bool pbuffer):
51            _width(width),
52            _height(height),
53            _pbuffer(pbuffer) {}
54       
55        virtual osg::GraphicsContext* allocate()
56        {
57            osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
58            traits->width = _width;
59            traits->height = _height;
60            traits->windowDecoration = true;
61            traits->pbuffer = _pbuffer;
62           
63            osg::ref_ptr<osg::GraphicsContext> window = osg::GraphicsContext::createGraphicsContext(traits.get());
64            if (window.valid())
65            {
66                if (window->realize())
67                {
68                    return window.release();
69                }
70                else
71                {
72                    if (_pbuffer) throw "Failed to realize PixelBuffer";
73                    else  throw "Failed to realize GraphicsWindow";
74                }
75            }
76            else
77            {
78                if (_pbuffer) throw "Failed to create PixelBuffer";
79                else  throw "Failed to create GraphicsWindow";
80            }
81            return 0;
82        }
83       
84
85    protected:
86   
87        int     _width;
88        int     _height;
89        bool    _pbuffer;
90};
91
92////////////////////////////////////////////////////////////////////////
93//
94// Wrap StateAttribute
95class StateAttributeObject : public GLObject
96{
97    public:
98   
99        StateAttributeObject(osg::StateAttribute* sa): _attribute(sa) {}
100       
101        void apply(osg::State& state)
102        {
103            _attribute->apply(state);
104           
105            if (state.checkGLErrors(_attribute.get()))
106            {
107                throw "OpenGL error";
108            }
109        }
110       
111        osg::ref_ptr<osg::StateAttribute> _attribute;
112};
113
114/////////////////////////////////////////////////////////////////////////
115//
116// Texture test
117class TextureTest : public GLMemoryTest
118{
119    public:
120
121        TextureTest(int width=1, int height=1, int depth=1):
122            _width(width),
123            _height(height),
124            _depth(depth) {}
125       
126        virtual GLObject* allocate()
127        {
128            if (_depth>1)
129            {
130                osg::ref_ptr<osg::Image> image = new osg::Image;
131                image->allocateImage(_width, _height, _depth, GL_RGBA, GL_UNSIGNED_BYTE);
132               
133                osg::ref_ptr<osg::Texture3D> texture = new osg::Texture3D;
134                texture->setImage(image.get());
135                texture->setResizeNonPowerOfTwoHint(false);
136               
137                return new StateAttributeObject(texture.get());
138            }
139            if (_height>1)
140            {
141                osg::ref_ptr<osg::Image> image = new osg::Image;
142                image->allocateImage(_width, _height, 1, GL_RGBA, GL_UNSIGNED_BYTE);
143               
144                osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D;
145                texture->setImage(image.get());
146                texture->setResizeNonPowerOfTwoHint(false);
147               
148                return new StateAttributeObject(texture.get());
149            }
150            if (_width>1)
151            {
152                osg::ref_ptr<osg::Image> image = new osg::Image;
153                image->allocateImage(_width, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE);
154               
155                osg::ref_ptr<osg::Texture1D> texture = new osg::Texture1D;
156                texture->setImage(image.get());
157                texture->setResizeNonPowerOfTwoHint(false);
158               
159                return new StateAttributeObject(texture.get());
160            }
161            else
162            {
163                throw "Invalid texture size of 0,0,0";
164            }
165            return 0;           
166        }
167       
168
169    protected:
170   
171        int     _width;
172        int     _height;
173        int     _depth;
174};
175
176/////////////////////////////////////////////////////////////////////////
177//
178// Texture test
179class FboTest : public GLMemoryTest
180{
181    public:
182
183        FboTest(int width=1024, int height=1024, int depth=2):
184            _width(width),
185            _height(height),
186            _depth(depth) {}
187       
188        virtual GLObject* allocate()
189        {
190            osg::ref_ptr<osg::FrameBufferObject> fbo = new osg::FrameBufferObject;
191
192            if (_depth>=1) fbo->setAttachment(osg::Camera::COLOR_BUFFER, osg::FrameBufferAttachment(new osg::RenderBuffer(_width, _height, GL_RGBA)));
193            if (_depth>=2) fbo->setAttachment(osg::Camera::DEPTH_BUFFER, osg::FrameBufferAttachment(new osg::RenderBuffer(_width, _height, GL_DEPTH_COMPONENT24)));
194
195            return new StateAttributeObject(fbo.get());
196        }
197       
198
199    protected:
200   
201        int     _width;
202        int     _height;
203        int     _depth;
204};
205
206int main( int argc, char **argv )
207{
208    osg::ArgumentParser arguments(&argc,argv);
209   
210    typedef std::list< osg::ref_ptr<MemoryTest> > Tests;
211    Tests tests;
212   
213    int width, height, depth;
214    while(arguments.read("--pbuffer",width,height)) { tests.push_back(new ContextTest(width, height, true)); }
215    while(arguments.read("--pbuffer")) { tests.push_back(new ContextTest(512, 512, true)); }
216
217    while(arguments.read("--window",width,height)) { tests.push_back(new ContextTest(width, height, false)); }
218    while(arguments.read("--window")) { tests.push_back(new ContextTest(512,512, false)); }
219
220    while(arguments.read("--texture",width,height,depth)) { tests.push_back(new TextureTest(width,height,depth)); }
221    while(arguments.read("--texture",width,height)) { tests.push_back(new TextureTest(width,height,1)); }
222    while(arguments.read("--texture",width)) { tests.push_back(new TextureTest(width,1,1)); }
223
224    while(arguments.read("--fbo",width,height,depth)) { tests.push_back(new FboTest(width,height,depth)); }
225    while(arguments.read("--fbo",width,height)) { tests.push_back(new FboTest(width,height,2)); }
226    while(arguments.read("--fbo")) { tests.push_back(new FboTest(1024,1024,2)); }
227
228    int maxNumContextIterations = 1;
229    while(arguments.read("-c",maxNumContextIterations)) {}
230
231    int maxNumGLIterations = 1000;
232    while(arguments.read("-g",maxNumGLIterations)) {}
233
234    typedef std::list< osg::ref_ptr<GLMemoryTest> > GLMemoryTests;
235    typedef std::list< osg::ref_ptr<ContextTest> > ContextTests;
236
237   
238    ContextTests contextTests;
239    GLMemoryTests glMemoryTests;
240   
241    for(Tests::iterator itr = tests.begin();
242        itr != tests.end();
243        ++itr)
244    {
245        MemoryTest* test = itr->get();
246        if (dynamic_cast<GLMemoryTest*>(test)!=0)
247        {
248            glMemoryTests.push_back(dynamic_cast<GLMemoryTest*>(test));
249        }
250        else if (dynamic_cast<ContextTest*>(test)!=0)
251        {
252            contextTests.push_back(dynamic_cast<ContextTest*>(test));
253        }
254    }
255
256    typedef std::list< osg::ref_ptr<osg::GraphicsContext> > Contexts;
257    typedef std::list< osg::ref_ptr<GLObject> > GLObjects;
258    Contexts allocatedContexts;
259    GLObjects glObjects;
260
261    int numContextIterations = 0;
262    int numGLObjectIterations = 0;
263    int numGLObjectsApplied = 0;
264    try
265    {
266        for(; numGLObjectIterations<maxNumGLIterations; ++numGLObjectIterations)
267        {   
268            for(GLMemoryTests::iterator itr = glMemoryTests.begin();
269                itr != glMemoryTests.end();
270                ++itr)
271            {
272                osg::ref_ptr<GLObject> glObject = (*itr)->allocate();
273                if (glObject.valid()) glObjects.push_back(glObject.get());
274            }
275        }
276       
277        for(;numContextIterations<maxNumContextIterations; ++numContextIterations)
278        {
279            printf("iteration %i\n",numContextIterations);
280            for(ContextTests::iterator itr = contextTests.begin();
281                itr != contextTests.end();
282                ++itr)
283            {
284                osg::ref_ptr<osg::GraphicsContext> context = (*itr)->allocate();
285                if (context.valid())
286                {
287                    allocatedContexts.push_back(context);
288
289                    context->makeCurrent();
290                   
291                    for(GLObjects::iterator gitr = glObjects.begin();
292                        gitr != glObjects.end();
293                        ++gitr)
294                    {
295                        (*gitr)->apply(*(context->getState()));
296                        ++numGLObjectsApplied;
297                    }
298                   
299                    context->releaseContext();
300                }
301            }
302        }
303    }
304    catch(const char* errorString)
305    {
306        printf("Exception caught, contexts completed = %i, gl objects successfully applied =%i, error = %s\n",numContextIterations, numGLObjectsApplied, errorString);
307        return 1;
308    }
309    catch(...)
310    {
311        printf("Exception caught, contexts completed = %i, gl objects successfully applied =%i\n",numContextIterations, numGLObjectsApplied);
312        return 1;
313    }
314
315    printf("Successful completion, contexts created = %i, gl objects applied =%i\n",numContextIterations, numGLObjectsApplied);
316   
317    return 0;
318}
Note: See TracBrowser for help on using the browser.