Hello Robert,
Following the advice given on osg-users, here's the small fix I made to
make sure the ScreenCaptureHandler doesn't attach the
WindowCaptureCallback to HUD cameras (cameras in the scene graph).
The test I used is to check if the camera has any parents. Is that OK?
It works in my app, and seems to work well in osgviewer as well (it
captures the stats display if it's shown, as I expect it to, for
example). Testing if camera->getView() != 0 didn't seem to work well for
that case (it didn't capture the stats display if it was shown, only the
main scene).
Thanks,
J-S
--
______________________________________________________
Jean-Sebastien Guay [email protected]
http://www.cm-labs.com/
http://whitestar02.webhop.org/
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* OpenSceneGraph Public License for more details.
*/
#include <sstream>
#include <osgDB/WriteFile>
#include <osgViewer/Viewer>
#include <osgViewer/ViewerEventHandlers>
#include <string.h>
namespace osgViewer
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// WindowCaptureCallback
//
// From osgscreencapture example
/** Callback which will be added to a viewer's camera to do the actual screen
capture. */
class WindowCaptureCallback : public osg::Camera::DrawCallback
{
public:
enum Mode
{
READ_PIXELS,
SINGLE_PBO,
DOUBLE_PBO,
TRIPLE_PBO
};
enum FramePosition
{
START_FRAME,
END_FRAME
};
WindowCaptureCallback(int numFrames, Mode mode, FramePosition position,
GLenum readBuffer);
FramePosition getFramePosition() const { return _position; }
void setCaptureOperation(ScreenCaptureHandler::CaptureOperation*
operation);
ScreenCaptureHandler::CaptureOperation* getCaptureOperation() { return
_contextDataMap.begin()->second->_captureOperation.get(); }
void setFramesToCapture(int numFrames) { _numFrames = numFrames; }
int getFramesToCapture() const { return _numFrames; }
virtual void operator () (osg::RenderInfo& renderInfo) const;
struct OSGVIEWER_EXPORT ContextData : public osg::Referenced
{
ContextData(osg::GraphicsContext* gc, Mode mode, GLenum readBuffer);
void getSize(osg::GraphicsContext* gc, int& width, int& height);
void updateTimings(osg::Timer_t tick_start,
osg::Timer_t tick_afterReadPixels,
osg::Timer_t tick_afterMemCpy,
osg::Timer_t tick_afterCaptureOperation,
unsigned int dataSize);
void read();
void readPixels();
void singlePBO(osg::GLBufferObject::Extensions* ext);
void multiPBO(osg::GLBufferObject::Extensions* ext);
typedef std::vector< osg::ref_ptr<osg::Image> >
ImageBuffer;
typedef std::vector< GLuint > PBOBuffer;
osg::GraphicsContext* _gc;
unsigned int _index;
Mode _mode;
GLenum _readBuffer;
GLenum _pixelFormat;
GLenum _type;
int _width;
int _height;
unsigned int _currentImageIndex;
ImageBuffer _imageBuffer;
unsigned int _currentPboIndex;
PBOBuffer _pboBuffer;
unsigned int _reportTimingFrequency;
unsigned int _numTimeValuesRecorded;
double _timeForReadPixels;
double _timeForMemCpy;
double _timeForCaptureOperation;
double _timeForFullCopy;
double _timeForFullCopyAndOperation;
osg::Timer_t _previousFrameTick;
osg::ref_ptr<ScreenCaptureHandler::CaptureOperation>
_captureOperation;
};
typedef std::map<osg::GraphicsContext*, osg::ref_ptr<ContextData> >
ContextDataMap;
ContextData* createContextData(osg::GraphicsContext* gc) const;
ContextData* getContextData(osg::GraphicsContext* gc) const;
Mode _mode;
FramePosition _position;
GLenum _readBuffer;
mutable OpenThreads::Mutex _mutex;
mutable ContextDataMap _contextDataMap;
mutable int _numFrames;
osg::ref_ptr<ScreenCaptureHandler::CaptureOperation>
_defaultCaptureOperation;
};
WindowCaptureCallback::ContextData::ContextData(osg::GraphicsContext* gc, Mode
mode, GLenum readBuffer)
: _gc(gc),
_index(_gc->getState()->getContextID()),
_mode(mode),
_readBuffer(readBuffer),
_pixelFormat(GL_RGBA),
_type(GL_UNSIGNED_BYTE),
_width(0),
_height(0),
_currentImageIndex(0),
_currentPboIndex(0),
_reportTimingFrequency(100),
_numTimeValuesRecorded(0),
_timeForReadPixels(0.0),
_timeForMemCpy(0.0),
_timeForCaptureOperation(0.0),
_timeForFullCopy(0.0),
_timeForFullCopyAndOperation(0.0),
_previousFrameTick(0)
{
_previousFrameTick = osg::Timer::instance()->tick();
osg::NotifySeverity level = osg::INFO;
if (gc->getTraits())
{
if (gc->getTraits()->alpha)
{
osg::notify(level)<<"ScreenCaptureHandler: Selected GL_RGBA read
back format"<<std::endl;
_pixelFormat = GL_RGBA;
}
else
{
osg::notify(level)<<"ScreenCaptureHandler: Selected GL_RGB read
back format"<<std::endl;
_pixelFormat = GL_RGB;
}
}
getSize(gc, _width, _height);
//osg::notify(osg::NOTICE)<<"Window size "<<_width<<",
"<<_height<<std::endl;
// single buffered image
_imageBuffer.push_back(new osg::Image);
// double buffer PBO.
switch(_mode)
{
case(READ_PIXELS):
osg::notify(level)<<"ScreenCaptureHandler: Reading window using
glReadPixels, without PixelBufferObject."<<std::endl;
break;
case(SINGLE_PBO):
osg::notify(level)<<"ScreenCaptureHandler: Reading window using
glReadPixels, with a single PixelBufferObject."<<std::endl;
_pboBuffer.push_back(0);
break;
case(DOUBLE_PBO):
osg::notify(level)<<"ScreenCaptureHandler: Reading window using
glReadPixels, with a double buffer PixelBufferObject."<<std::endl;
_pboBuffer.push_back(0);
_pboBuffer.push_back(0);
break;
case(TRIPLE_PBO):
osg::notify(level)<<"ScreenCaptureHandler: Reading window using
glReadPixels, with a triple buffer PixelBufferObject."<<std::endl;
_pboBuffer.push_back(0);
_pboBuffer.push_back(0);
_pboBuffer.push_back(0);
break;
default:
break;
}
}
void WindowCaptureCallback::ContextData::getSize(osg::GraphicsContext* gc, int&
width, int& height)
{
if (gc->getTraits())
{
width = gc->getTraits()->width;
height = gc->getTraits()->height;
}
}
void WindowCaptureCallback::ContextData::updateTimings(osg::Timer_t tick_start,
osg::Timer_t
tick_afterReadPixels,
osg::Timer_t
tick_afterMemCpy,
osg::Timer_t
tick_afterCaptureOperation,
unsigned int dataSize)
{
_timeForReadPixels = osg::Timer::instance()->delta_s(tick_start,
tick_afterReadPixels);
_timeForMemCpy = osg::Timer::instance()->delta_s(tick_afterReadPixels,
tick_afterMemCpy);
_timeForCaptureOperation =
osg::Timer::instance()->delta_s(tick_afterMemCpy, tick_afterCaptureOperation);
_timeForFullCopy = osg::Timer::instance()->delta_s(tick_start,
tick_afterMemCpy);
_timeForFullCopyAndOperation = osg::Timer::instance()->delta_s(tick_start,
tick_afterCaptureOperation);
}
void WindowCaptureCallback::ContextData::read()
{
osg::GLBufferObject::Extensions* ext =
osg::GLBufferObject::getExtensions(_gc->getState()->getContextID(),true);
if (ext->isPBOSupported() && !_pboBuffer.empty())
{
if (_pboBuffer.size()==1)
{
singlePBO(ext);
}
else
{
multiPBO(ext);
}
}
else
{
readPixels();
}
}
void WindowCaptureCallback::ContextData::readPixels()
{
unsigned int nextImageIndex = (_currentImageIndex+1)%_imageBuffer.size();
unsigned int nextPboIndex = _pboBuffer.empty() ? 0 :
(_currentPboIndex+1)%_pboBuffer.size();
int width=0, height=0;
getSize(_gc, width, height);
if (width!=_width || _height!=height)
{
//osg::notify(osg::NOTICE)<<" Window resized "<<width<<",
"<<height<<std::endl;
_width = width;
_height = height;
}
osg::Image* image = _imageBuffer[_currentImageIndex].get();
osg::Timer_t tick_start = osg::Timer::instance()->tick();
#if 1
image->readPixels(0,0,_width,_height,
_pixelFormat,_type);
#endif
osg::Timer_t tick_afterReadPixels = osg::Timer::instance()->tick();
if (_captureOperation.valid())
{
(*_captureOperation)(*image, _index);
}
osg::Timer_t tick_afterCaptureOperation = osg::Timer::instance()->tick();
updateTimings(tick_start, tick_afterReadPixels, tick_afterReadPixels,
tick_afterCaptureOperation, image->getTotalSizeInBytes());
_currentImageIndex = nextImageIndex;
_currentPboIndex = nextPboIndex;
}
void
WindowCaptureCallback::ContextData::singlePBO(osg::GLBufferObject::Extensions*
ext)
{
unsigned int nextImageIndex = (_currentImageIndex+1)%_imageBuffer.size();
int width=0, height=0;
getSize(_gc, width, height);
if (width!=_width || _height!=height)
{
//osg::notify(osg::NOTICE)<<" Window resized "<<width<<",
"<<height<<std::endl;
_width = width;
_height = height;
}
GLuint& pbo = _pboBuffer[0];
osg::Image* image = _imageBuffer[_currentImageIndex].get();
if (image->s() != _width ||
image->t() != _height)
{
//osg::notify(osg::NOTICE)<<"ScreenCaptureHandler: Allocating image
"<<std::endl;
image->allocateImage(_width, _height, 1, _pixelFormat, _type);
if (pbo!=0)
{
//osg::notify(osg::NOTICE)<<"ScreenCaptureHandler: deleting pbo
"<<pbo<<std::endl;
ext->glDeleteBuffers (1, &pbo);
pbo = 0;
}
}
if (pbo==0)
{
ext->glGenBuffers(1, &pbo);
ext->glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, pbo);
ext->glBufferData(GL_PIXEL_PACK_BUFFER_ARB,
image->getTotalSizeInBytes(), 0, GL_STREAM_READ);
//osg::notify(osg::NOTICE)<<"ScreenCaptureHandler: Generating pbo
"<<pbo<<std::endl;
}
else
{
ext->glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, pbo);
}
osg::Timer_t tick_start = osg::Timer::instance()->tick();
#if 1
glReadPixels(0, 0, _width, _height, _pixelFormat, _type, 0);
#endif
osg::Timer_t tick_afterReadPixels = osg::Timer::instance()->tick();
GLubyte* src = (GLubyte*)ext->glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB,
GL_READ_ONLY_ARB);
if(src)
{
memcpy(image->data(), src, image->getTotalSizeInBytes());
ext->glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB);
}
ext->glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, 0);
osg::Timer_t tick_afterMemCpy = osg::Timer::instance()->tick();
if (_captureOperation.valid())
{
(*_captureOperation)(*image, _index);
}
osg::Timer_t tick_afterCaptureOperation = osg::Timer::instance()->tick();
updateTimings(tick_start, tick_afterReadPixels, tick_afterMemCpy,
tick_afterCaptureOperation, image->getTotalSizeInBytes());
_currentImageIndex = nextImageIndex;
}
void
WindowCaptureCallback::ContextData::multiPBO(osg::GLBufferObject::Extensions*
ext)
{
unsigned int nextImageIndex = (_currentImageIndex+1)%_imageBuffer.size();
unsigned int nextPboIndex = (_currentPboIndex+1)%_pboBuffer.size();
int width=0, height=0;
getSize(_gc, width, height);
if (width!=_width || _height!=height)
{
//osg::notify(osg::NOTICE)<<" Window resized "<<width<<",
"<<height<<std::endl;
_width = width;
_height = height;
}
GLuint& copy_pbo = _pboBuffer[_currentPboIndex];
GLuint& read_pbo = _pboBuffer[nextPboIndex];
osg::Image* image = _imageBuffer[_currentImageIndex].get();
if (image->s() != _width ||
image->t() != _height)
{
//osg::notify(osg::NOTICE)<<"ScreenCaptureHandler: Allocating image
"<<std::endl;
image->allocateImage(_width, _height, 1, _pixelFormat, _type);
if (read_pbo!=0)
{
//osg::notify(osg::NOTICE)<<"ScreenCaptureHandler: deleting pbo
"<<read_pbo<<std::endl;
ext->glDeleteBuffers (1, &read_pbo);
read_pbo = 0;
}
if (copy_pbo!=0)
{
//osg::notify(osg::NOTICE)<<"ScreenCaptureHandler: deleting pbo
"<<copy_pbo<<std::endl;
ext->glDeleteBuffers (1, ©_pbo);
copy_pbo = 0;
}
}
bool doCopy = copy_pbo!=0;
if (copy_pbo==0)
{
ext->glGenBuffers(1, ©_pbo);
ext->glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, copy_pbo);
ext->glBufferData(GL_PIXEL_PACK_BUFFER_ARB,
image->getTotalSizeInBytes(), 0, GL_STREAM_READ);
//osg::notify(osg::NOTICE)<<"ScreenCaptureHandler: Generating pbo
"<<read_pbo<<std::endl;
}
if (read_pbo==0)
{
ext->glGenBuffers(1, &read_pbo);
ext->glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, read_pbo);
ext->glBufferData(GL_PIXEL_PACK_BUFFER_ARB,
image->getTotalSizeInBytes(), 0, GL_STREAM_READ);
//osg::notify(osg::NOTICE)<<"ScreenCaptureHandler: Generating pbo
"<<read_pbo<<std::endl;
}
else
{
ext->glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, read_pbo);
}
osg::Timer_t tick_start = osg::Timer::instance()->tick();
#if 1
glReadPixels(0, 0, _width, _height, _pixelFormat, _type, 0);
#endif
osg::Timer_t tick_afterReadPixels = osg::Timer::instance()->tick();
if (doCopy)
{
ext->glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, copy_pbo);
GLubyte* src = (GLubyte*)ext->glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB,
GL_READ_ONLY_ARB);
if(src)
{
memcpy(image->data(), src, image->getTotalSizeInBytes());
ext->glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB);
}
if (_captureOperation.valid())
{
(*_captureOperation)(*image, _index);
}
}
ext->glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, 0);
osg::Timer_t tick_afterMemCpy = osg::Timer::instance()->tick();
updateTimings(tick_start, tick_afterReadPixels, tick_afterMemCpy,
tick_afterMemCpy, image->getTotalSizeInBytes());
_currentImageIndex = nextImageIndex;
_currentPboIndex = nextPboIndex;
}
WindowCaptureCallback::WindowCaptureCallback(int numFrames, Mode mode,
FramePosition position, GLenum readBuffer)
: _mode(mode),
_position(position),
_readBuffer(readBuffer),
_numFrames(numFrames)
{
}
WindowCaptureCallback::ContextData*
WindowCaptureCallback::createContextData(osg::GraphicsContext* gc) const
{
WindowCaptureCallback::ContextData* cd = new
WindowCaptureCallback::ContextData(gc, _mode, _readBuffer);
cd->_captureOperation = _defaultCaptureOperation;
return cd;
}
WindowCaptureCallback::ContextData*
WindowCaptureCallback::getContextData(osg::GraphicsContext* gc) const
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
osg::ref_ptr<ContextData>& data = _contextDataMap[gc];
if (!data) data = createContextData(gc);
return data.get();
}
void
WindowCaptureCallback::setCaptureOperation(ScreenCaptureHandler::CaptureOperation*
operation)
{
_defaultCaptureOperation = operation;
// Set the capture operation for each ContextData.
for (ContextDataMap::iterator it = _contextDataMap.begin(); it !=
_contextDataMap.end(); ++it)
{
it->second->_captureOperation = operation;
}
}
void WindowCaptureCallback::operator () (osg::RenderInfo& renderInfo) const
{
#if !defined(OSG_GLES1_AVAILABLE) && !defined(OSG_GLES2_AVAILABLE)
glReadBuffer(_readBuffer);
#endif
osg::GraphicsContext* gc = renderInfo.getState()->getGraphicsContext();
osg::ref_ptr<ContextData> cd = getContextData(gc);
cd->read();
// If _numFrames is > 0 it means capture that number of frames.
if (_numFrames > 0)
{
--_numFrames;
if (_numFrames == 0)
{
// the callback must remove itself when it's done.
if (_position == START_FRAME)
renderInfo.getCurrentCamera()->setInitialDrawCallback(0);
if (_position == END_FRAME)
renderInfo.getCurrentCamera()->setFinalDrawCallback(0);
}
}
int prec = osg::notify(osg::INFO).precision(5);
osg::notify(osg::INFO) << "ScreenCaptureHandler: "
<< "copy=" << (cd->_timeForFullCopy*1000.0f)
<< "ms, "
<< "operation=" <<
(cd->_timeForCaptureOperation*1000.0f) << "ms, "
<< "total=" <<
(cd->_timeForFullCopyAndOperation*1000.0f) << std::endl;
osg::notify(osg::INFO).precision(prec);
cd->_timeForFullCopy = 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ScreenCaptureHandler::WriteToFile
//
ScreenCaptureHandler::WriteToFile::WriteToFile(const std::string& filename,
const std::string& extension,
SavePolicy savePolicy)
: _filename(filename), _extension(extension), _savePolicy(savePolicy)
{
}
void ScreenCaptureHandler::WriteToFile::operator () (const osg::Image& image,
const unsigned int context_id)
{
if (_savePolicy == SEQUENTIAL_NUMBER)
{
if (_contextSaveCounter.size() <= context_id)
{
unsigned int oldSize = _contextSaveCounter.size();
_contextSaveCounter.resize(context_id + 1);
// Initialize all new values to 0 since context ids may not be
consecutive.
for (unsigned int i = oldSize; i <= context_id; i++)
_contextSaveCounter[i] = 0;
}
}
std::stringstream filename;
filename << _filename << "_" << context_id;
if (_savePolicy == SEQUENTIAL_NUMBER)
filename << "_" << _contextSaveCounter[context_id];
filename << "." << _extension;
osgDB::writeImageFile(image, filename.str());
osg::notify(osg::INFO)<<"ScreenCaptureHandler: Taking a screenshot, saved
as '"<<filename.str()<<"'"<<std::endl;
if (_savePolicy == SEQUENTIAL_NUMBER)
{
_contextSaveCounter[context_id]++;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ScreenCaptureHandler
//
ScreenCaptureHandler::ScreenCaptureHandler(CaptureOperation* defaultOperation,
int numFrames)
: _startCapture(false),
_stopCapture(false),
_keyEventTakeScreenShot('c'),
_keyEventToggleContinuousCapture('C'),
_callback(new WindowCaptureCallback( numFrames,
WindowCaptureCallback::READ_PIXELS,
// WindowCaptureCallback::SINGLE_PBO,
// WindowCaptureCallback::DOUBLE_PBO,
// WindowCaptureCallback::TRIPLE_PBO,
WindowCaptureCallback::END_FRAME,
GL_BACK))
{
if (defaultOperation)
setCaptureOperation(defaultOperation);
else
setCaptureOperation(new WriteToFile("screen_shot", "jpg"));
}
void ScreenCaptureHandler::setCaptureOperation(CaptureOperation* operation)
{
WindowCaptureCallback* callback =
static_cast<WindowCaptureCallback*>(_callback.get());
callback->setCaptureOperation(operation);
}
ScreenCaptureHandler::CaptureOperation*
ScreenCaptureHandler::getCaptureOperation() const
{
WindowCaptureCallback* callback =
static_cast<WindowCaptureCallback*>(_callback.get());
return callback->getCaptureOperation();
}
void ScreenCaptureHandler::addCallbackToViewer(osgViewer::ViewerBase& viewer)
{
osg::Camera* camera = findAppropriateCameraForCallback(viewer);
WindowCaptureCallback* callback =
static_cast<WindowCaptureCallback*>(_callback.get());
if (camera && callback->getFramePosition() ==
WindowCaptureCallback::START_FRAME)
{
camera->setInitialDrawCallback(_callback.get());
}
else
{
camera->setFinalDrawCallback(_callback.get());
}
}
void ScreenCaptureHandler::removeCallbackFromViewer(osgViewer::ViewerBase&
viewer)
{
osg::Camera* camera = findAppropriateCameraForCallback(viewer);
WindowCaptureCallback* callback =
static_cast<WindowCaptureCallback*>(_callback.get());
if (camera && callback->getFramePosition() ==
WindowCaptureCallback::START_FRAME)
{
camera->setInitialDrawCallback(0);
}
else
{
camera->setFinalDrawCallback(0);
}
}
osg::Camera*
ScreenCaptureHandler::findAppropriateCameraForCallback(osgViewer::ViewerBase&
viewer)
{
// Select either the first or the last active camera, depending on the
// frame position set in the callback.
// One case where testing the node mask is important is when the stats
// handler has been initialized, but stats are not displayed. In that
// case, there is a post render camera on the viewer, but its node mask
// is zero, so the callback added to that camera would never be called.
// Also, only main and slave cameras should be selected, so cameras with
// parents (cameras in the scene graph) should not be used.
WindowCaptureCallback* callback =
static_cast<WindowCaptureCallback*>(_callback.get());
if (callback->getFramePosition() == WindowCaptureCallback::START_FRAME)
{
osgViewer::ViewerBase::Contexts contexts;
viewer.getContexts(contexts);
for(osgViewer::ViewerBase::Contexts::iterator itr = contexts.begin();
itr != contexts.end();
++itr)
{
osg::GraphicsContext* context = *itr;
osg::GraphicsContext::Cameras& cameras = context->getCameras();
osg::Camera* firstCamera = 0;
for(osg::GraphicsContext::Cameras::iterator cam_itr =
cameras.begin();
cam_itr != cameras.end();
++cam_itr)
{
if (firstCamera)
{
if ((*cam_itr)->getRenderOrder() <
firstCamera->getRenderOrder())
{
if ((*cam_itr)->getNodeMask() != 0x0 &&
(*cam_itr)->getNumParents() == 0)
firstCamera = (*cam_itr);
}
if ((*cam_itr)->getRenderOrder() ==
firstCamera->getRenderOrder() &&
(*cam_itr)->getRenderOrderNum() <
firstCamera->getRenderOrderNum())
{
if ((*cam_itr)->getNodeMask() != 0x0 &&
(*cam_itr)->getNumParents() == 0)
firstCamera = (*cam_itr);
}
}
else
{
if ((*cam_itr)->getNodeMask() != 0x0 &&
(*cam_itr)->getNumParents() == 0)
firstCamera = *cam_itr;
}
}
if (firstCamera)
{
//osg::notify(osg::NOTICE)<<"ScreenCaptureHandler: First camera
"<<firstCamera<<std::endl;
return firstCamera;
}
else
{
osg::notify(osg::NOTICE)<<"ScreenCaptureHandler: No camera
found"<<std::endl;
}
}
}
else
{
osgViewer::ViewerBase::Contexts contexts;
viewer.getContexts(contexts);
for(osgViewer::ViewerBase::Contexts::iterator itr = contexts.begin();
itr != contexts.end();
++itr)
{
osg::GraphicsContext* context = *itr;
osg::GraphicsContext::Cameras& cameras = context->getCameras();
osg::Camera* lastCamera = 0;
for(osg::GraphicsContext::Cameras::iterator cam_itr =
cameras.begin();
cam_itr != cameras.end();
++cam_itr)
{
if (lastCamera)
{
if ((*cam_itr)->getRenderOrder() >
lastCamera->getRenderOrder())
{
if ((*cam_itr)->getNodeMask() != 0x0 &&
(*cam_itr)->getNumParents() == 0)
lastCamera = (*cam_itr);
}
if ((*cam_itr)->getRenderOrder() ==
lastCamera->getRenderOrder() &&
(*cam_itr)->getRenderOrderNum() >=
lastCamera->getRenderOrderNum())
{
if ((*cam_itr)->getNodeMask() != 0x0 &&
(*cam_itr)->getNumParents() == 0)
lastCamera = (*cam_itr);
}
}
else
{
if ((*cam_itr)->getNodeMask() != 0x0 &&
(*cam_itr)->getNumParents() == 0)
lastCamera = *cam_itr;
}
}
if (lastCamera)
{
//osg::notify(osg::NOTICE)<<"ScreenCaptureHandler: Last camera
"<<lastCamera<<std::endl;
return lastCamera;
}
else
{
osg::notify(osg::NOTICE)<<"ScreenCaptureHandler: No camera
found"<<std::endl;
}
}
}
return 0;
}
// aa will point to an osgViewer::View, so we will take a screenshot
// of that view's graphics contexts.
bool ScreenCaptureHandler::handle(const osgGA::GUIEventAdapter& ea,
osgGA::GUIActionAdapter& aa)
{
osgViewer::ViewerBase* viewer =
dynamic_cast<osgViewer::View*>(&aa)->getViewerBase();
if (!viewer) return false;
switch(ea.getEventType())
{
case (osgGA::GUIEventAdapter::FRAME):
{
// Booleans aren't the best way of doing this, but I want to do
// the actual adding here because I don't want to require
// startCapture() take a viewer as argument, which could not be
// the right one.
if (_startCapture)
{
// Start capturing with the currently set number of frames.
// If set to -1 it will capture continuously, if set to >0
// it will capture that number of frames.
_startCapture = false;
addCallbackToViewer(*viewer);
}
else if (_stopCapture)
{
_stopCapture = false;
removeCallbackFromViewer(*viewer);
}
}
case(osgGA::GUIEventAdapter::KEYUP):
{
if (ea.getKey() == _keyEventTakeScreenShot)
{
// Check that we will capture at least one frame.
// Just check for ==0, because >0 is means we're already
// capturing and <0 means it will capture all frames.
WindowCaptureCallback* callback =
static_cast<WindowCaptureCallback*>(_callback.get());
if (callback->getFramesToCapture() == 0)
{
setFramesToCapture(1);
}
addCallbackToViewer(*viewer);
return true;
}
if (ea.getKey() == _keyEventToggleContinuousCapture)
{
if (getFramesToCapture() < 0)
{
setFramesToCapture(0);
removeCallbackFromViewer(*viewer);
}
else
{
setFramesToCapture(-1);
addCallbackToViewer(*viewer);
}
return true;
}
break;
}
default:
break;
}
return false;
}
/** Capture the given viewer's views on the next frame. */
void ScreenCaptureHandler::captureNextFrame(osgViewer::ViewerBase& viewer)
{
addCallbackToViewer(viewer);
}
/** Set the number of frames to capture. */
void ScreenCaptureHandler::setFramesToCapture(int numFrames)
{
WindowCaptureCallback* callback =
static_cast<WindowCaptureCallback*>(_callback.get());
callback->setFramesToCapture(numFrames);
}
/** Get the number of frames to capture. */
int ScreenCaptureHandler::getFramesToCapture() const
{
WindowCaptureCallback* callback =
static_cast<WindowCaptureCallback*>(_callback.get());
return callback->getFramesToCapture();
}
/** Start capturing at the end of the next frame. */
void ScreenCaptureHandler::startCapture()
{
if (getFramesToCapture() != 0)
_startCapture = true;
}
/** Stop capturing. */
void ScreenCaptureHandler::stopCapture()
{
_stopCapture = true;
}
/** Get the keyboard and mouse usage of this manipulator.*/
void ScreenCaptureHandler::getUsage(osg::ApplicationUsage& usage) const
{
{
std::ostringstream ostr;
ostr<<char(_keyEventTakeScreenShot);
usage.addKeyboardMouseBinding(ostr.str(),"Take screenshot.");
}
{
std::ostringstream ostr;
ostr<<char(_keyEventToggleContinuousCapture);
usage.addKeyboardMouseBinding(ostr.str(),"Toggle continuous screen
capture.");
}
}
}
_______________________________________________
osg-submissions mailing list
[email protected]
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
