← Back to branch summary

~ubuntu-branches/ubuntu/trusty/openscenegraph/trusty

« back to all changes in this revision

Viewing changes to OpenSceneGraph/src/osgViewer/Renderer.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Cyril Brulebois
  • Date: 2008-07-29 04:34:38 UTC
  • mfrom: (1.1.6 upstream) (2.1.3 lenny)
  • Revision ID: james.westby@ubuntu.com-20080729043438-no1h9h0dpsrlzp1y
http://bugs.debian.org/477353
http://bugs.debian.org/482239
* Non-maintainer upload.
* No longer try to detect (using /proc/cpuinfo when available) how many
  CPUs are available, fixing the FTBFS (due to -j0) on various platforms
  (Closes: #477353). The right way to do it is to support parallel=n in
  DEB_BUILD_OPTIONS (see Debian Policy §4.9.1), and adequate support has
  been implemented.
* Add patch to fix FTBFS due to the build system now refusing to handle
  whitespaces (Policy CMP0004 say the logs), thanks to Andreas Putzo who
  provided it (Closes: #482239):
   - debian/patches/fix-cmp0004-build-failure.dpatch
* Remove myself from Uploaders, as requested a while ago, done by Luk in
  his 2.2.0-2.1 NMU, which was never acknowledged.

Show diffs side-by-side

added added

removed removed

Lines of Context:
OpenSceneGraph/src/osgViewer/Renderer.cpp
30
30
using namespace osgViewer;
31
31
 
32
32
//#define DEBUG_MESSAGE osg::notify(osg::NOTICE)
33
 
#define DEBUG_MESSAGE osg::notify(osg::INFO)
 
33
#define DEBUG_MESSAGE osg::notify(osg::DEBUG_FP)
34
34
 
35
35
 
36
36
OpenGLQuerySupport::OpenGLQuerySupport():
161
161
Renderer::Renderer(osg::Camera* camera):
162
162
    osg::GraphicsOperation("Renderer",true),
163
163
    OpenGLQuerySupport(),
 
164
    _targetFrameRate(100.0),
 
165
    _minimumTimeAvailableForGLCompileAndDeletePerFrame(0.001),
 
166
    _flushTimeRatio(0.5),
 
167
    _conservativeTimeRatio(0.5),
164
168
    _camera(camera),
165
169
    _done(false),
166
170
    _graphicsThreadDoesCull(true)
254
258
 
255
259
    if (_done || _graphicsThreadDoesCull) return;
256
260
 
257
 
    // note we assume lock has already been aquired.
 
261
    // note we assume lock has already been acquired.
258
262
    osgUtil::SceneView* sceneView = _availableQueue.takeFront();
259
263
 
260
264
    DEBUG_MESSAGE<<"cull() got SceneView "<<sceneView<<std::endl;
274
278
        const osg::FrameStamp* fs = state->getFrameStamp();
275
279
        int frameNumber = fs ? fs->getFrameNumber() : 0;
276
280
 
277
 
        // do cull taversal
 
281
        // do cull traversal
278
282
        osg::Timer_t beforeCullTick = osg::Timer::instance()->tick();
279
283
 
280
284
        sceneView->inheritCullSettings(*(sceneView->getCamera()));
356
360
            state->getDynamicObjectRenderingCompletedCallback()->completed(state);
357
361
        }
358
362
 
359
 
        bool aquireGPUStats = stats && _timerQuerySupported && stats->collectStats("gpu");
 
363
        bool acquireGPUStats = stats && _timerQuerySupported && stats->collectStats("gpu");
360
364
 
361
 
        if (aquireGPUStats) 
 
365
        if (acquireGPUStats) 
362
366
        {
363
367
            checkQuery(stats);
364
368
        }
365
369
 
366
 
        // do draw traveral
367
 
        if (aquireGPUStats) 
 
370
        // do draw traversal
 
371
        if (acquireGPUStats) 
368
372
        {
369
373
            checkQuery(stats);
370
374
            beginQuery(frameNumber);
389
393
 
390
394
        _availableQueue.add(sceneView);
391
395
 
392
 
        double availableTime = 0.004; // 4 ms
393
 
        if (databasePager && databasePager->requiresExternalCompileGLObjects(sceneView->getState()->getContextID()))
394
 
        {
395
 
            databasePager->compileGLObjects(*(sceneView->getState()), availableTime);
396
 
        }
397
 
 
398
 
        if (compileThread)
399
 
        {
400
 
            compileThread->add(_flushOperation.get());
401
 
        }
402
 
        else
403
 
        {
404
 
            sceneView->flushDeletedGLObjects(availableTime);
405
 
        }
406
 
 
407
 
        if (aquireGPUStats)
 
396
        osg::Timer_t afterDispatchTick = osg::Timer::instance()->tick();
 
397
 
 
398
        double dispatchTime = osg::Timer::instance()->delta_s(beforeDrawTick, afterDispatchTick);
 
399
 
 
400
        // now flush delete OpenGL objects and compile any objects as required by the DatabasePager
 
401
        flushAndCompile(dispatchTime, sceneView, databasePager, compileThread);
 
402
    
 
403
        if (acquireGPUStats)
408
404
        {
409
405
            endQuery();
410
406
            checkQuery(stats);
464
460
        initialize(state);
465
461
    }
466
462
 
467
 
    bool aquireGPUStats = stats && _timerQuerySupported && stats->collectStats("gpu");
 
463
    bool acquireGPUStats = stats && _timerQuerySupported && stats->collectStats("gpu");
468
464
 
469
 
    if (aquireGPUStats) 
 
465
    if (acquireGPUStats) 
470
466
    {
471
467
        checkQuery(stats);
472
468
    }
473
469
 
474
 
    // do cull taversal
 
470
    // do cull traversal
475
471
    osg::Timer_t beforeCullTick = osg::Timer::instance()->tick();
476
472
 
477
473
    sceneView->inheritCullSettings(*(sceneView->getCamera()));
487
483
#endif
488
484
 
489
485
 
490
 
    // do draw traveral
491
 
    if (aquireGPUStats) 
 
486
    // do draw traversal
 
487
    if (acquireGPUStats) 
492
488
    {
493
489
        checkQuery(stats);
494
490
        beginQuery(frameNumber);
511
507
        sceneView->draw();
512
508
    }
513
509
 
514
 
    double availableTime = 0.004; // 4 ms
515
 
    if (databasePager && databasePager->requiresExternalCompileGLObjects(sceneView->getState()->getContextID()))
516
 
    {
517
 
        databasePager->compileGLObjects(*(sceneView->getState()), availableTime);
518
 
    }
519
 
 
520
 
    if (compileThread)
521
 
    {
522
 
        compileThread->add(_flushOperation.get());
523
 
    }
524
 
    else
525
 
    {
526
 
        sceneView->flushDeletedGLObjects(availableTime);
527
 
    }
528
 
 
529
 
    if (aquireGPUStats)
 
510
    osg::Timer_t afterDispatchTick = osg::Timer::instance()->tick();
 
511
    double cullAndDispatchTime = osg::Timer::instance()->delta_s(beforeCullTick, afterDispatchTick);
 
512
 
 
513
    // now flush delete OpenGL objects and compile any objects as required by the DatabasePager
 
514
    flushAndCompile(cullAndDispatchTime, sceneView, databasePager, compileThread);
 
515
 
 
516
 
 
517
    if (acquireGPUStats)
530
518
    {
531
519
        endQuery();
532
520
        checkQuery(stats);
551
539
 
552
540
}
553
541
 
 
542
void Renderer::flushAndCompile(double currentElapsedFrameTime, osgUtil::SceneView* sceneView, osgDB::DatabasePager* databasePager, osg::GraphicsThread* compileThread)
 
543
{
 
544
    
 
545
    double targetFrameRate = _targetFrameRate;
 
546
    double minimumTimeAvailableForGLCompileAndDeletePerFrame = _minimumTimeAvailableForGLCompileAndDeletePerFrame;
 
547
 
 
548
    if (databasePager)
 
549
    {
 
550
        targetFrameRate = std::min(targetFrameRate, databasePager->getTargetFrameRate());
 
551
        minimumTimeAvailableForGLCompileAndDeletePerFrame = std::min(minimumTimeAvailableForGLCompileAndDeletePerFrame, databasePager->getMinimumTimeAvailableForGLCompileAndDeletePerFrame());
 
552
    }
 
553
    
 
554
    double targetFrameTime = 1.0/targetFrameRate;
 
555
 
 
556
    double availableTime = std::max((targetFrameTime - currentElapsedFrameTime)*_conservativeTimeRatio,
 
557
                                    minimumTimeAvailableForGLCompileAndDeletePerFrame);
 
558
 
 
559
    double flushTime = availableTime * _flushTimeRatio;
 
560
    double compileTime = availableTime - flushTime;
 
561
 
 
562
#if 0
 
563
    osg::notify(osg::NOTICE)<<"total availableTime = "<<availableTime*1000.0<<std::endl;
 
564
    osg::notify(osg::NOTICE)<<"      flushTime     = "<<flushTime*1000.0<<std::endl;
 
565
    osg::notify(osg::NOTICE)<<"      compileTime   = "<<compileTime*1000.0<<std::endl;
 
566
#endif
 
567
 
 
568
    if (compileThread)
 
569
    {
 
570
        compileThread->add(_flushOperation.get());
 
571
    }
 
572
    else
 
573
    {
 
574
        sceneView->flushDeletedGLObjects(flushTime);
 
575
    }
 
576
 
 
577
    // if any time left over from flush add this to compile time.        
 
578
    if (flushTime>0.0) compileTime += flushTime;
 
579
 
 
580
#if 0
 
581
    osg::notify(osg::NOTICE)<<"      revised compileTime   = "<<compileTime*1000.0<<std::endl;
 
582
#endif
 
583
 
 
584
    if (databasePager && databasePager->requiresExternalCompileGLObjects(sceneView->getState()->getContextID()))
 
585
    {
 
586
        databasePager->compileGLObjects(*(sceneView->getState()), compileTime);
 
587
    }
 
588
}
 
589
 
554
590
void Renderer::operator () (osg::Object* object)
555
591
{
556
592
    osg::GraphicsContext* context = dynamic_cast<osg::GraphicsContext*>(object);