void Window::_setupObjectManager()
{
if( !glewGetContext( ))
return;
_releaseObjectManager();
Window* sharedWindow = getSharedContextWindow();
ObjectManager* sharedOM = sharedWindow ? sharedWindow->getObjectManager():0;
if( sharedOM )
_objectManager = new ObjectManager( sharedOM );
else
_objectManager = new ObjectManager( glewGetContext( ));
}
void Window::_setupObjectManager()
{
if( !glewGetContext( ))
return;
_releaseObjectManager();
const Window* sharedWindow = getSharedContextWindow();
if( sharedWindow && sharedWindow != this )
_objectManager = sharedWindow->_objectManager;
else
{
util::ObjectManager om( glewGetContext( ));
_objectManager = om;
}
}
~texture_internal()
{
if(id && glewGetContext())
{
glDeleteTextures(1, &id);
}
}
ObjectManager& ObjectManager::operator = ( const ObjectManager& rhs )
{
if( this != &rhs )
_impl = rhs._impl;
LBASSERT( glewGetContext( ));
return *this;
}
~renderbuffer_internal()
{
if(id && glewGetContext())
{
glDeleteRenderbuffers(1, &id);
}
}
/**
* Function for creating and holding of shared context.
* Generation and uploading of new textures over some period with sleep time.
*/
void AsyncFetcher::run()
{
EQASSERT( !_sharedContextWindow );
_sharedContextWindow = initSharedContextWindow( _wnd );
_outQueue.push( TextureId( )); // unlock pipe thread
if( !_sharedContextWindow )
return;
_objectManager = new ObjectManager( glewGetContext( ));
EQINFO << "async fetcher initialized: " << _wnd << std::endl;
int i = 0;
bool running = true;
co::base::sleep( 1000 ); // imitate loading of the first texture
while( running )
{
// generate new texture
eq::util::Texture* tx = _objectManager->newEqTexture( ++i,
GL_TEXTURE_2D );
tx->init( GL_RGBA8, 64, 64 );
int j = 0;
co::base::RNG rng;
for( int y = 0; y < 64; ++y )
{
for( int x = 0; x < 64; ++x )
{
const GLbyte rnd = rng.get< uint8_t >() % 127;
const GLbyte val = (x / 8) % 2 == (y / 8) % 2 ? rnd : 0;
_tmpTexture[ j++ ] = val;
_tmpTexture[ j++ ] = val;
_tmpTexture[ j++ ] = val;
_tmpTexture[ j++ ] = val;
}
}
tx->upload( 64, 64, _tmpTexture );
EQ_GL_CALL( glFinish( ));
// add new texture to the pool
_outQueue.push( TextureId( tx->getName( ), i ));
// imitate hard work of loading something else
co::base::sleep( rng.get< uint32_t >() % 5000u );
// clean unused textures
int keyToDelete = 0;
while( _inQueue.tryPop( keyToDelete ))
{
if( keyToDelete )
{
EQWARN << "Deleting eq texture " << keyToDelete << std::endl;
_objectManager->deleteEqTexture( keyToDelete );
}
else
running = false;
}
}
deleteSharedContextWindow( _wnd, &_sharedContextWindow, &_objectManager );
}
/**
* Function for creating and holding of shared context.
* Generation and uploading of new textures over some period with sleep time.
*/
void AsyncFetcher::run()
{
LBASSERT( _sharedWindow );
if( !_sharedWindow )
return;
_sharedWindow->makeCurrent();
eq::util::ObjectManager objects( glewGetContext( ));
lunchbox::Bufferb textureData( 64*64*4 );
LBINFO << "async fetcher initialized" << std::endl;
bool running = true;
lunchbox::sleep( 1000 ); // imitate loading of the first texture
for( uint8_t* i = 0; running; ++i )
{
// generate new texture
eq::util::Texture* tx = objects.newEqTexture( i, GL_TEXTURE_2D );
tx->init( GL_RGBA8, 64, 64 );
int j = 0;
lunchbox::RNG rng;
for( int y = 0; y < 64; ++y )
{
for( int x = 0; x < 64; ++x )
{
const GLbyte rnd = rng.get< uint8_t >() % 127;
const GLbyte val = (x / 8) % 2 == (y / 8) % 2 ? rnd : 0;
textureData[ j++ ] = val;
textureData[ j++ ] = val;
textureData[ j++ ] = val;
textureData[ j++ ] = val;
}
}
tx->upload( 64, 64, textureData.getData( ));
EQ_GL_CALL( glFinish( ));
// add new texture to the pool
_outQueue.push( TextureId( tx->getName(), i ));
// imitate hard work of loading something else
lunchbox::sleep( rng.get< uint32_t >() % 5000u );
// clean unused textures
const void* keyToDelete = 0;
while( _inQueue.tryPop( keyToDelete ))
{
if( keyToDelete )
{
LBWARN << "Deleting eq texture " << keyToDelete << std::endl;
objects.deleteEqTexture( keyToDelete );
}
else
running = false;
}
}
objects.deleteAll();
}
version_check()
{
if(!glewGetContext())
{
k3d::log() << warning << "No context defined to determine Mesa version" << std::endl;
return;
}
const k3d::string_t version(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
const k3d::string_t vendor(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
k3d::log() << info << "OpenGL version: " << version << ", vendor: " << vendor << std::endl;
try
{
if(vendor == "Tungsten Graphics, Inc" || vendor == "Mesa Project")
{
std::vector<k3d::string_t> tokens;
boost::split(tokens, version, boost::is_any_of(" "));
if(tokens.size() > 2 && tokens[1] == "Mesa")
{
const k3d::string_t version_number = tokens[2];
std::vector<k3d::string_t> bad_tokens; // Strip off any trailing '-devel' and so on
boost::split(bad_tokens, version_number, boost::is_any_of("-"));
std::vector<k3d::string_t> version_tokens;
boost::split(version_tokens, bad_tokens[0], boost::is_any_of("."));
if(version_tokens.size() > 1)
{
const k3d::uint_t min_major = 7; // minimal major version
const k3d::uint_t min_minor = 5; // minimal minor version
const k3d::uint_t min_patch = 1; // minimal patch version
const k3d::uint_t major = boost::lexical_cast<k3d::uint_t>(version_tokens[0]);
const k3d::uint_t minor = boost::lexical_cast<k3d::uint_t>(version_tokens[1]);
if(major < min_major || (major == min_major && minor < min_minor) || (major == min_major && minor == min_minor && (version_tokens.size() == 2 || boost::lexical_cast<k3d::uint_t>(version_tokens[2]) < min_patch)))
{
k3d::user_interface().nag_message(
"MesaVersionCheck/1",
k3d::ustring::from_utf8(k3d::string_cast(boost::format(_("Your OpenGL version is %1%.")) % version)),
k3d::ustring::from_utf8(_("On your platform, Mesa versions earlier than 7.5.1 are known to cause problems with face selection. If you experience this, please upgrade your Mesa library. See http://bugs.freedesktop.org/show_bug.cgi?id=16866 for detailed information.")));
}
}
}
}
}
catch(std::runtime_error& E)
{
k3d::log() << warning << "error parsing mesa version: " << E.what() << std::endl;
}
}
bool AccumBufferObject::init( const PixelViewport& pvp,
const GLuint textureFormat )
{
_pvp = pvp;
_texture = new Texture( GL_TEXTURE_RECTANGLE_ARB, glewGetContext( ));
_texture->init( textureFormat, pvp.w, pvp.h );
const Error error = FrameBufferObject::init( pvp.w, pvp.h,
GL_RGBA32F, 0, 0 );
if( error )
{
exit();
return false;
}
unbind();
return true;
}
bool Window::configInitGL( const eq::uint128_t& )
{
Pipe* pipe = static_cast<Pipe*>( getPipe() );
Renderer* renderer = pipe->getRenderer();
if( !renderer )
return false;
if( !GLEW_ARB_shader_objects )
{
sendError( ERROR_EVOLVE_ARB_SHADER_OBJECTS_MISSING );
return false;
}
if( !GLEW_EXT_blend_func_separate )
{
sendError( ERROR_EVOLVE_EXT_BLEND_FUNC_SEPARATE_MISSING );
return false;
}
if( !GLEW_ARB_multitexture )
{
sendError( ERROR_EVOLVE_ARB_MULTITEXTURE_MISSING );
return false;
}
glEnable( GL_SCISSOR_TEST ); // needed to constrain channel viewport
glClear( GL_COLOR_BUFFER_BIT );
swapBuffers();
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
renderer->glewSetContext( glewGetContext( ));
if( !renderer->loadShaders( ))
{
sendError( ERROR_EVOLVE_LOADSHADERS_FAILED );
return false;
}
_loadLogo();
return true;
}
Impl( const uint32_t samplesPerRay,
const uint32_t samplesPerPixel,
const VolumeInformation& volInfo )
: _framebufferTexture( GL_TEXTURE_RECTANGLE_ARB, glewGetContext( ))
, _nSamplesPerRay( samplesPerRay )
, _nSamplesPerPixel( samplesPerPixel )
, _computedSamplesPerRay( samplesPerRay )
, _volInfo( volInfo )
, _transferFunctionTexture( 0 )
{
TransferFunction1D transferFunction;
initTransferFunction( transferFunction );
// TODO: Add the shaders from resource directory
const int error = _shaders.loadShaders( ShaderData( vertRayCast_glsl,
fragRayCast_glsl ));
if( error != GL_NO_ERROR )
LBTHROW( std::runtime_error( "Can't load glsl shaders: " +
eq::glError( error ) +
where( __FILE__, __LINE__ )));
}
//\brief
// initialize the gl extension functions address.
static bool InitializeGlew()
{
GLenum err;
GLContext ctx;
/* create OpenGL rendering context */
InitContext(&ctx);
if (GL_TRUE == CreateContext(&ctx))
{
std::cout << "Error: CreateContext failed" << std::endl;
DestroyContext(&ctx);
return false;
}
/* initialize GLEW */
glewExperimental = GL_TRUE;
#ifdef GLEW_MX
err = glewContextInit(glewGetContext());
# ifdef _WIN32
err = err || wglewContextInit(wglewGetContext());
# elif !defined(__APPLE__) && !defined(__HAIKU__) || defined(GLEW_APPLE_GLX)
err = err || glxewContextInit(glxewGetContext());
# endif
#else
err = glewInit();
#endif
if (GLEW_OK != err)
{
std::cout << "Error [main]: glewInit failed: " << glewGetErrorString(err) << std::endl;
DestroyContext(&ctx);
return false;
}
DestroyContext(&ctx);
return true;
}
int main (int argc, char** argv)
{
GLuint err;
struct createParams params =
{
#if defined(__OSMESA__)
-1, /* bit depth */
#elif defined(_WIN32)
-1, /* pixelformat */
#elif !defined(__HAIKU__) && !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
"", /* display */
-1, /* visual */
#endif
0, /* major */
0, /* minor */
0, /* profile mask */
0 /* flags */
};
if (glewParseArgs(argc-1, argv+1, ¶ms))
{
fprintf(stderr, "Usage: glewinfo "
#if defined(__OSMESA__)
#elif defined(_WIN32)
"[-pf <pixelformat>] "
#elif !defined(__HAIKU__) && !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
"[-display <display>] "
"[-visual <visual id>] "
#endif
"[-version <OpenGL version>] "
"[-profile core|compatibility] "
"[-flag debug|forward]"
"\n");
return 1;
}
if (GL_TRUE == glewCreateContext(¶ms))
{
fprintf(stderr, "Error: glewCreateContext failed\n");
glewDestroyContext();
return 1;
}
glewExperimental = GL_TRUE;
#ifdef GLEW_MX
err = glewContextInit(glewGetContext());
#if defined(__OSMESA__)
err = err || osmewContextInit(osmewGetContext());
#elif defined(_WIN32)
err = err || wglewContextInit(wglewGetContext());
#elif !defined(__HAIKU__) && !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
err = err || glxewContextInit(glxewGetContext());
#endif
#else
err = glewInit();
#endif
if (GLEW_OK != err)
{
fprintf(stderr, "Error [main]: glewInit failed: %s\n", glewGetErrorString(err));
glewDestroyContext();
return 1;
}
#if defined(_WIN32)
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
if (fopen_s(&f, "glewinfo.txt", "w") != 0)
f = stdout;
#else
f = fopen("glewinfo.txt", "w");
#endif /* _MSC_VER */
if (f == NULL) f = stdout;
#else
f = stdout;
#endif /* _WIN32 */
fprintf(f, "---------------------------\n");
fprintf(f, " GLEW Extension Info\n");
fprintf(f, "---------------------------\n\n");
fprintf(f, "GLEW version %s\n", glewGetString(GLEW_VERSION));
#if defined(__OSMESA__)
fprintf(f, "Reporting capabilitiees of OSMesa\n");
#elif defined(_WIN32)
fprintf(f, "Reporting capabilities of pixelformat %d\n", params.pixelformat);
#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
fprintf(f, "Reporting capabilities of display %s, visual 0x%x\n",
params.display == NULL ? getenv("DISPLAY") : params.display, params.visual);
#endif /* __OSMESA__ */
fprintf(f, "Running on a %s from %s\n",
glGetString(GL_RENDERER), glGetString(GL_VENDOR));
fprintf(f, "OpenGL version %s is supported\n", glGetString(GL_VERSION));
glewInfo();
#if defined(__OSMESA__)
osmewInfo();
#elif defined(_WIN32)
wglewInfo();
#else
glxewInfo();
#endif /* __OSMESA__ */
if (f != stdout) fclose(f);
glewDestroyContext();
return 0;
}
int
main (int argc, char** argv)
{
GLenum err;
GLContext ctx;
/* ---------------------------------------------------------------------- */
/* parse arguments */
if (GL_TRUE == ParseArgs(argc-1, argv+1))
{
#if defined(_WIN32)
fprintf(stderr, "Usage: visualinfo [-a] [-s] [-h] [-pf <id>]\n");
fprintf(stderr, " -a: show all visuals\n");
fprintf(stderr, " -s: display to stdout instead of visualinfo.txt\n");
fprintf(stderr, " -pf <id>: use given pixelformat\n");
fprintf(stderr, " -h: this screen\n");
#else
fprintf(stderr, "Usage: visualinfo [-h] [-display <display>] [-visual <id>]\n");
fprintf(stderr, " -h: this screen\n");
fprintf(stderr, " -display <display>: use given display\n");
fprintf(stderr, " -visual <id>: use given visual\n");
#endif
return 1;
}
/* ---------------------------------------------------------------------- */
/* create OpenGL rendering context */
InitContext(&ctx);
if (GL_TRUE == CreateContext(&ctx))
{
fprintf(stderr, "Error: CreateContext failed\n");
DestroyContext(&ctx);
return 1;
}
/* ---------------------------------------------------------------------- */
/* initialize GLEW */
glewExperimental = GL_TRUE;
#ifdef GLEW_MX
err = glewContextInit(glewGetContext());
# ifdef _WIN32
err = err || wglewContextInit(wglewGetContext());
# elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
err = err || glxewContextInit(glxewGetContext());
# endif
#else
err = glewInit();
#endif
if (GLEW_OK != err)
{
fprintf(stderr, "Error [main]: glewInit failed: %s\n", glewGetErrorString(err));
DestroyContext(&ctx);
return 1;
}
/* ---------------------------------------------------------------------- */
/* open file */
#if defined(_WIN32)
if (!displaystdout)
file = fopen("visualinfo.txt", "w");
if (file == NULL)
file = stdout;
#else
file = stdout;
#endif
/* ---------------------------------------------------------------------- */
/* output header information */
/* OpenGL extensions */
fprintf(file, "OpenGL vendor string: %s\n", glGetString(GL_VENDOR));
fprintf(file, "OpenGL renderer string: %s\n", glGetString(GL_RENDERER));
fprintf(file, "OpenGL version string: %s\n", glGetString(GL_VERSION));
fprintf(file, "OpenGL extensions (GL_): \n");
PrintExtensions((char*)glGetString(GL_EXTENSIONS));
/* GLU extensions */
fprintf(file, "GLU version string: %s\n", gluGetString(GLU_VERSION));
fprintf(file, "GLU extensions (GLU_): \n");
PrintExtensions((char*)gluGetString(GLU_EXTENSIONS));
/* ---------------------------------------------------------------------- */
/* extensions string */
#if defined(_WIN32)
/* WGL extensions */
if (WGLEW_ARB_extensions_string || WGLEW_EXT_extensions_string)
{
fprintf(file, "WGL extensions (WGL_): \n");
PrintExtensions(wglGetExtensionsStringARB ?
(char*)wglGetExtensionsStringARB(ctx.dc) :
(char*)wglGetExtensionsStringEXT());
}
#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
#else
/* GLX extensions */
fprintf(file, "GLX extensions (GLX_): \n");
PrintExtensions(glXQueryExtensionsString(glXGetCurrentDisplay(),
DefaultScreen(glXGetCurrentDisplay())));
#endif
/* ---------------------------------------------------------------------- */
/* enumerate all the formats */
VisualInfo(&ctx);
/* ---------------------------------------------------------------------- */
/* release resources */
DestroyContext(&ctx);
if (file != stdout)
fclose(file);
return 0;
}
void Channel::_testDepthAssemble()
{
glGetError(); // reset
//----- setup constant data
const eq::Images& images = _frame.getImages();
eq::Image* image = images[ 0 ];
LBASSERT( image );
const eq::PixelViewport& pvp = getPixelViewport();
const eq::Vector2i offset( pvp.x, pvp.y );
eq::Vector2i area;
area.x() = pvp.w;
lunchbox::Clock clock;
eq::util::ObjectManager& glObjects = getObjectManager();
const GLEWContext* glewContext = glewGetContext();
//----- test depth-based assembly algorithms
for( unsigned i = 0; i < NUM_IMAGES; ++i )
{
image = images[ i ];
LBASSERT( image );
image->setPixelViewport( pvp );
}
area.y() = pvp.h;
for( uint64_t i = 0; i < NUM_IMAGES; ++i )
{
_draw( co::uint128_t( i ) );
// fill depth & color image
image = images[ i ];
LBCHECK( image->allocDownloader( eq::Frame::BUFFER_COLOR,
EQ_COMPRESSOR_TRANSFER_RGBA_TO_BGRA,
glewContext ));
LBCHECK( image->allocDownloader( eq::Frame::BUFFER_DEPTH,
EQ_COMPRESSOR_TRANSFER_DEPTH_TO_DEPTH_UNSIGNED_INT,
glewContext ));
image->clearPixelData( eq::Frame::BUFFER_COLOR );
image->clearPixelData( eq::Frame::BUFFER_DEPTH );
image->startReadback( eq::Frame::BUFFER_COLOR | eq::Frame::BUFFER_DEPTH,
pvp, eq::Zoom::NONE, glObjects );
image->finishReadback( glObjects.glewGetContext( ));
LBASSERT( image->hasPixelData( eq::Frame::BUFFER_COLOR ));
LBASSERT( image->hasPixelData( eq::Frame::BUFFER_DEPTH ));
if( i == NUM_IMAGES-1 )
_saveImage( image,"EQ_COMPRESSOR_DATATYPE_DEPTH_UNSIGNED_INT",
"depthAssemble" );
// benchmark
eq::Compositor::ImageOp op;
op.channel = this;
op.buffers = eq::Frame::BUFFER_COLOR | eq::Frame::BUFFER_DEPTH;
op.offset = offset;
// fixed-function
std::stringstream formatType;
formatType << "depth, GL1.1, " << i+1 << " images";
clock.reset();
for( unsigned j = 0; j <= i; ++j )
eq::Compositor::assembleImageDB_FF( images[j], op );
float msec = clock.getTimef();
_sendEvent( ASSEMBLE, msec, area, formatType.str(), 0, 0 );
// GLSL
if( GLEW_VERSION_2_0 )
{
formatType.str("");
formatType << "depth, GLSL, " << i+1 << " images";
clock.reset();
for( unsigned j = 0; j <= i; ++j )
eq::Compositor::assembleImageDB_GLSL( images[j], op );
msec = clock.getTimef();
_sendEvent( ASSEMBLE, msec, area, formatType.str(), 0, 0 );
}
// CPU
formatType.str("");
formatType << "depth, CPU, " << i+1 << " images";
std::vector< eq::Frame* > frames;
frames.push_back( &_frame );
clock.reset();
eq::Compositor::assembleFramesCPU( frames, this );
msec = clock.getTimef();
_sendEvent( ASSEMBLE, msec, area, formatType.str(), 0, 0 );
}
}
void Channel::_testDepthAssemble()
{
//----- setup constant data
const eq::Images& images = _frame.getImages();
eq::Image* image = images[ 0 ];
LBASSERT( image );
eq::Config* config = getConfig();
const eq::PixelViewport& pvp = getPixelViewport();
const eq::Vector2i offset( pvp.x, pvp.y );
ConfigEvent event = _createConfigEvent();
event.area.x() = pvp.w;
lunchbox::Clock clock;
eq::Window::ObjectManager* glObjects = getObjectManager();
const GLEWContext* glewContext = glewGetContext();
//----- test depth-based assembly algorithms
for( unsigned i = 0; i < NUM_IMAGES; ++i )
{
image = images[ i ];
LBASSERT( image );
image->setPixelViewport( pvp );
}
event.area.y() = pvp.h;
for( unsigned i = 0; i < NUM_IMAGES; ++i )
{
_draw( i );
// fill depth & color image
image = images[ i ];
LBCHECK( image->allocDownloader( eq::Frame::BUFFER_COLOR,
EQ_COMPRESSOR_TRANSFER_RGBA_TO_BGRA,
glewContext ));
LBCHECK( image->allocDownloader( eq::Frame::BUFFER_DEPTH,
EQ_COMPRESSOR_TRANSFER_DEPTH_TO_DEPTH_UNSIGNED_INT,
glewContext ));
image->clearPixelData( eq::Frame::BUFFER_COLOR );
image->clearPixelData( eq::Frame::BUFFER_DEPTH );
image->startReadback( eq::Frame::BUFFER_COLOR | eq::Frame::BUFFER_DEPTH,
pvp, eq::Zoom::NONE, glObjects );
image->finishReadback( eq::Zoom::NONE, glObjects->glewGetContext( ));
if( i == NUM_IMAGES-1 )
_saveImage( image,"EQ_COMPRESSOR_DATATYPE_DEPTH_UNSIGNED_INT",
"depthAssemble" );
// benchmark
eq::Compositor::ImageOp op;
op.channel = this;
op.buffers = eq::Frame::BUFFER_COLOR | eq::Frame::BUFFER_DEPTH;
op.offset = offset;
// fixed-function
event.data.type = ConfigEvent::ASSEMBLE;
snprintf( event.formatType, 32, "depth, GL1.1, %d images", i+1 );
clock.reset();
for( unsigned j = 0; j <= i; ++j )
eq::Compositor::assembleImageDB_FF( images[j], op );
event.msec = clock.getTimef();
config->sendEvent( event );
// GLSL
if( GLEW_VERSION_2_0 )
{
snprintf( event.formatType, 32, "depth, GLSL, %d images", i+1 );
clock.reset();
for( unsigned j = 0; j <= i; ++j )
eq::Compositor::assembleImageDB_GLSL( images[j], op );
event.msec = clock.getTimef();
config->sendEvent( event );
}
// CPU
snprintf( event.formatType, 32, "depth, CPU, %d images", i+1 );
std::vector< eq::Frame* > frames;
frames.push_back( &_frame );
clock.reset();
eq::Compositor::assembleFramesCPU( frames, this );
event.msec = clock.getTimef();
config->sendEvent( event );
}
}
void Channel::_testFormats( float applyZoom )
{
//----- setup constant data
const eq::Images& images = _frame.getImages();
eq::Image* image = images[ 0 ];
LBASSERT( image );
Config* config = static_cast< Config* >( getConfig( ));
const eq::PixelViewport& pvp = getPixelViewport();
const eq::Vector2i offset( pvp.x, pvp.y );
const eq::Zoom zoom( applyZoom, applyZoom );
lunchbox::Clock clock;
eq::Window::ObjectManager* glObjects = getObjectManager();
//----- test all default format/type combinations
ConfigEvent event = _createConfigEvent();
glGetError();
for( uint32_t i=0; _enums[i].internalFormatString; ++i )
{
const uint32_t internalFormat = _enums[i].internalFormat;
image->flush();
image->setInternalFormat( eq::Frame::BUFFER_COLOR, internalFormat );
image->setQuality( eq::Frame::BUFFER_COLOR, 0.f );
image->setAlphaUsage( false );
const GLEWContext* glewContext = glewGetContext();
std::vector< uint32_t > names;
image->findTransferers( eq::Frame::BUFFER_COLOR, glewContext, names );
for( std::vector< uint32_t >::const_iterator j = names.begin();
j != names.end(); ++j )
{
_draw( 0 );
// setup
event.formatType[31] = '\0';
event.data.type = ConfigEvent::READBACK;
image->allocDownloader( eq::Frame::BUFFER_COLOR, *j, glewContext );
image->setPixelViewport( pvp );
const uint32_t outputToken =
image->getExternalFormat( eq::Frame::BUFFER_COLOR );
snprintf( event.formatType, 32, "%s/%x/%x",
_enums[i].internalFormatString, outputToken, *j );
// read
glFinish();
size_t nLoops = 0;
clock.reset();
while( clock.getTime64() < 100 /*ms*/ )
{
image->startReadback( eq::Frame::BUFFER_COLOR, pvp, zoom,
glObjects );
image->finishReadback( zoom, glObjects->glewGetContext( ));
++nLoops;
}
glFinish();
event.msec = clock.getTimef() / float( nLoops );
const eq::PixelData& pixels =
image->getPixelData( eq::Frame::BUFFER_COLOR );
event.area.x() = pixels.pvp.w;
event.area.y() = pixels.pvp.h;
event.dataSizeGPU = pixels.pvp.getArea() * _enums[i].pixelSize;
event.dataSizeCPU =
image->getPixelDataSize( eq::Frame::BUFFER_COLOR );
GLenum error = glGetError();
if( error != GL_NO_ERROR )
event.msec = -static_cast<float>( error );
config->sendEvent( event );
// write
eq::Compositor::ImageOp op;
op.channel = this;
op.buffers = eq::Frame::BUFFER_COLOR;
op.offset = offset;
op.zoom = zoom;
event.data.type = ConfigEvent::ASSEMBLE;
event.dataSizeCPU =
image->getPixelDataSize( eq::Frame::BUFFER_COLOR );
clock.reset();
eq::Compositor::assembleImage( image, op );
event.msec = clock.getTimef();
const eq::PixelData& pixelA =
image->getPixelData( eq::Frame::BUFFER_COLOR );
event.area.x() = pixelA.pvp.w;
event.area.y() = pixelA.pvp.h;
event.dataSizeGPU =
image->getPixelDataSize( eq::Frame::BUFFER_COLOR );
error = glGetError();
if( error != GL_NO_ERROR )
event.msec = -static_cast<float>( error );
config->sendEvent( event );
}
}
}
void Channel::_testFormats( float applyZoom )
{
glGetError(); // reset
//----- setup constant data
const eq::Images& images = _frame.getImages();
eq::Image* image = images[ 0 ];
LBASSERT( image );
const eq::PixelViewport& pvp = getPixelViewport();
const eq::Vector2i offset( pvp.x, pvp.y );
const eq::Zoom zoom( applyZoom, applyZoom );
lunchbox::Clock clock;
eq::util::ObjectManager& glObjects = getObjectManager();
//----- test all default format/type combinations
for( uint32_t i=0; _enums[i].internalFormatString; ++i )
{
const uint32_t internalFormat = _enums[i].internalFormat;
image->flush();
image->setInternalFormat( eq::Frame::BUFFER_COLOR, internalFormat );
image->setQuality( eq::Frame::BUFFER_COLOR, 0.f );
image->setAlphaUsage( false );
const GLEWContext* glewContext = glewGetContext();
const std::vector< uint32_t >& names =
image->findTransferers( eq::Frame::BUFFER_COLOR, glewContext );
for( std::vector< uint32_t >::const_iterator j = names.begin();
j != names.end(); ++j )
{
_draw( co::uint128_t( ));
image->allocDownloader( eq::Frame::BUFFER_COLOR, *j, glewContext );
image->setPixelViewport( pvp );
const uint32_t outputToken =
image->getExternalFormat( eq::Frame::BUFFER_COLOR );
std::stringstream formatType;
formatType << std::hex << *j << ':'
<< _enums[i].internalFormatString << '/' << outputToken
<< std::dec;
// read
glFinish();
size_t nLoops = 0;
try
{
clock.reset();
while( clock.getTime64() < 100 /*ms*/ )
{
image->startReadback( eq::Frame::BUFFER_COLOR, pvp, zoom,
glObjects );
image->finishReadback( glObjects.glewGetContext( ));
++nLoops;
}
glFinish();
const float msec = clock.getTimef() / float( nLoops );
const GLenum error = glGetError(); // release mode
if( error != GL_NO_ERROR )
throw eq::GLException( error );
const eq::PixelData& pixels =
image->getPixelData( eq::Frame::BUFFER_COLOR );
const eq::Vector2i area( pixels.pvp.w, pixels.pvp.h );
const uint64_t dataSizeGPU = area.x() * area.y() *
_enums[i].pixelSize;
const uint64_t dataSizeCPU =
image->getPixelDataSize( eq::Frame::BUFFER_COLOR );
_sendEvent( READBACK, msec, area, formatType.str(), dataSizeGPU,
dataSizeCPU );
}
catch( const eq::GLException& e )
{
_sendEvent( READBACK, -static_cast<float>( e.glError ),
eq::Vector2i(), formatType.str(), 0, 0 );
continue;
}
// write
eq::Compositor::ImageOp op;
op.channel = this;
op.buffers = eq::Frame::BUFFER_COLOR;
op.offset = offset;
op.zoom = zoom;
const uint64_t dataSizeCPU =
image->getPixelDataSize( eq::Frame::BUFFER_COLOR );
try
{
clock.reset();
eq::Compositor::assembleImage( image, op );
glFinish();
const float msec = clock.getTimef() / float( nLoops );
const GLenum error = glGetError(); // release mode
if( error != GL_NO_ERROR )
throw eq::Exception( error );
const eq::PixelData& pixels =
image->getPixelData( eq::Frame::BUFFER_COLOR );
const eq::Vector2i area( pixels.pvp.w, pixels.pvp.h );
const uint64_t dataSizeGPU =
image->getPixelDataSize( eq::Frame::BUFFER_COLOR );
_sendEvent( ASSEMBLE, msec, area, formatType.str(), dataSizeGPU,
dataSizeCPU );
}
catch( const eq::GLException& e ) // debug mode
{
_sendEvent( ASSEMBLE, -static_cast<float>( e.glError ),
eq::Vector2i(), formatType.str(), 0, 0 );
}
}
}
}
bool Channel::_initAccum()
{
View* view = static_cast< View* >( getNativeView( ));
if( !view ) // Only alloc accum for dest
return true;
const eq::Eye eye = getEye();
Accum& accum = _accum[ lunchbox::getIndexOfLastBit( eye ) ];
if( accum.buffer ) // already done
return true;
if( accum.step == -1 ) // accum init failed last time
return false;
// Check unsupported cases
if( !eq::util::Accum::usesFBO( glewGetContext( )))
{
for( size_t i = 0; i < eq::NUM_EYES; ++i )
{
if( _accum[ i ].buffer )
{
LBWARN << "glAccum-based accumulation does not support "
<< "stereo, disabling idle anti-aliasing."
<< std::endl;
for( size_t j = 0; j < eq::NUM_EYES; ++j )
{
delete _accum[ j ].buffer;
_accum[ j ].buffer = 0;
_accum[ j ].step = -1;
}
view->setIdleSteps( 0 );
return false;
}
}
}
// set up accumulation buffer
accum.buffer = new eq::util::Accum( glewGetContext( ));
const eq::PixelViewport& pvp = getPixelViewport();
LBASSERT( pvp.isValid( ));
if( !accum.buffer->init( pvp, getWindow()->getColorFormat( )) ||
accum.buffer->getMaxSteps() < 256 )
{
LBWARN <<"Accumulation buffer initialization failed, "
<< "idle AA not available." << std::endl;
delete accum.buffer;
accum.buffer = 0;
accum.step = -1;
return false;
}
// else
LBVERB << "Initialized "
<< (accum.buffer->usesFBO() ? "FBO accum" : "glAccum")
<< " buffer for " << getName() << " " << getEye()
<< std::endl;
view->setIdleSteps( accum.buffer ? 256 : 0 );
return true;
}
void Channel::frameAssemble( const eq::uint128_t&, const eq::Frames& frames )
{
_startAssemble();
eq::PixelViewport coveredPVP;
eq::ImageOps dbImages;
eq::Zoom zoom( eq::Zoom::NONE );
// Make sure all frames are ready and gather some information on them
for( eq::Frame* frame : frames )
{
{
eq::ChannelStatistics stat( eq::Statistic::CHANNEL_FRAME_WAIT_READY,
this );
frame->waitReady( );
}
for( eq::Image* image : frame->getImages( ))
{
eq::ImageOp op( frame, image );
op.offset = frame->getOffset();
const eq::Range& range = image->getContext().range;
if( range == eq::Range::ALL ) // 2D frame, assemble directly
eq::Compositor::assembleImage( op, this );
else
{
dbImages.emplace_back( op );
zoom = frame->getZoom();
coveredPVP.merge( image->getPixelViewport() + frame->getOffset());
}
}
}
if( dbImages.empty( ))
{
resetAssemblyState();
return;
}
// calculate correct image sequence
const bool dbCompose = _image.getContext().range != eq::Range::ALL;
coveredPVP.intersect( getPixelViewport( ));
if( dbCompose && coveredPVP.hasArea( ))
{
eq::ImageOp op;
op.image = &_image;
op.buffers = eq::Frame::BUFFER_COLOR;
op.zoom = zoom;
op.offset = eq::Vector2i( coveredPVP.x, coveredPVP.y );
dbImages.emplace_back( op );
}
_orderImages( dbImages );
// check if current image is in proper position, read back if not
if( dbCompose )
{
if( _bgColor == eq::Vector3f() && dbImages.front().image == &_image)
dbImages.erase( dbImages.begin( ));
else if( coveredPVP.hasArea())
{
eq::util::ObjectManager& glObjects = getObjectManager();
eq::PixelViewport pvp = getRegion();
pvp.intersect( coveredPVP );
// Update range
eq::Range range( 1.f, 0.f );
for( const eq::ImageOp& op : dbImages )
{
const eq::Range& r = op.image->getContext().range;
range.start = std::min( range.start, r.start );
range.end = std::max( range.end, r.end );
}
eq::RenderContext context = _image.getContext();
context.range = range;
if( _image.startReadback( eq::Frame::BUFFER_COLOR, pvp, context,
zoom, glObjects ))
{
_image.finishReadback( glewGetContext( ));
}
clearViewport( coveredPVP );
}
}
glEnable( GL_BLEND );
LBASSERT( GLEW_EXT_blend_func_separate );
glBlendFuncSeparate( GL_ONE, GL_SRC_ALPHA, GL_ZERO, GL_SRC_ALPHA );
eq::Compositor::blendImages( dbImages, this, 0 );
resetAssemblyState();
}
bool Renderer::init( co::Object* initData )
{
_state = new State( glewGetContext( ));
return seq::Renderer::init( initData );
}
int main (void)
#endif
{
GLuint err;
#if defined(_WIN32) || !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
char* display = NULL;
int visual = -1;
if (glewParseArgs(argc-1, argv+1, &display, &visual))
{
#if defined(_WIN32)
fprintf(stderr, "Usage: glewinfo [-pf <id>]\n");
#else
fprintf(stderr, "Usage: glewinfo [-display <display>] [-visual <id>]\n");
#endif
return 1;
}
#endif
#if defined(_WIN32)
if (GL_TRUE == glewCreateContext(&visual))
#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
if (GL_TRUE == glewCreateContext())
#else
if (GL_TRUE == glewCreateContext(display, &visual))
#endif
{
fprintf(stderr, "Error: glewCreateContext failed\n");
glewDestroyContext();
return 1;
}
glewExperimental = GL_TRUE;
#ifdef GLEW_MX
err = glewContextInit(glewGetContext());
#ifdef _WIN32
err = err || wglewContextInit(wglewGetContext());
#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
err = err || glxewContextInit(glxewGetContext());
#endif
#else
err = glewInit();
#endif
if (GLEW_OK != err)
{
fprintf(stderr, "Error [main]: glewInit failed: %s\n", glewGetErrorString(err));
glewDestroyContext();
return 1;
}
#if defined(_WIN32)
f = fopen("glewinfo.txt", "w");
if (f == NULL) f = stdout;
#else
f = stdout;
#endif
fprintf(f, "---------------------------\n");
fprintf(f, " GLEW Extension Info\n");
fprintf(f, "---------------------------\n\n");
fprintf(f, "GLEW version %s\n", glewGetString(GLEW_VERSION));
#if defined(_WIN32)
fprintf(f, "Reporting capabilities of pixelformat %d\n", visual);
#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
fprintf(f, "Reporting capabilities of display %s, visual 0x%x\n",
display == NULL ? getenv("DISPLAY") : display, visual);
#endif
fprintf(f, "Running on a %s from %s\n",
glGetString(GL_RENDERER), glGetString(GL_VENDOR));
fprintf(f, "OpenGL version %s is supported\n", glGetString(GL_VERSION));
glewInfo();
#if defined(_WIN32)
wglewInfo();
#else
glxewInfo();
#endif
if (f != stdout) fclose(f);
glewDestroyContext();
return 0;
}
void Channel::_testTiledOperations()
{
//----- setup constant data
const eq::Images& images = _frame.getImages();
LBASSERT( images[0] );
eq::Config* config = getConfig();
const eq::PixelViewport& pvp = getPixelViewport();
const eq::Vector2i offset( pvp.x, pvp.y );
ConfigEvent event = _createConfigEvent();
event.area.x() = pvp.w;
lunchbox::Clock clock;
eq::Window::ObjectManager* glObjects = getObjectManager();
const GLEWContext* glewContext = glewGetContext();
//----- test tiled assembly algorithms
eq::PixelViewport subPVP = pvp;
subPVP.h /= NUM_IMAGES;
for( unsigned i = 0; i < NUM_IMAGES; ++i )
{
LBASSERT( images[ i ] );
images[ i ]->setPixelViewport( subPVP );
}
for( unsigned tiles = 0; tiles < NUM_IMAGES; ++tiles )
{
_draw( 0 );
event.area.y() = subPVP.h * (tiles+1);
//---- readback of 'tiles' depth images
event.data.type = ConfigEvent::READBACK;
snprintf( event.formatType, 32, "%d depth tiles", tiles+1 );
event.msec = 0;
for( unsigned j = 0; j <= tiles; ++j )
{
subPVP.y = pvp.y + j * subPVP.h;
eq::Image* image = images[ j ];
LBCHECK( image->allocDownloader( eq::Frame::BUFFER_DEPTH,
EQ_COMPRESSOR_TRANSFER_DEPTH_TO_DEPTH_UNSIGNED_INT,
glewContext ));
image->clearPixelData( eq::Frame::BUFFER_DEPTH );
clock.reset();
image->startReadback( eq::Frame::BUFFER_DEPTH, subPVP,
eq::Zoom::NONE, glObjects );
image->finishReadback( eq::Zoom::NONE, glObjects->glewGetContext( ));
event.msec += clock.getTimef();
}
config->sendEvent( event );
if( tiles == NUM_IMAGES-1 )
for( unsigned j = 0; j <= tiles; ++j )
_saveImage( images[j],
"EQ_COMPRESSOR_DATATYPE_DEPTH_UNSIGNED_INT",
"tiles" );
//---- readback of 'tiles' color images
event.data.type = ConfigEvent::READBACK;
snprintf( event.formatType, 32, "%d color tiles", tiles+1 );
event.msec = 0;
for( unsigned j = 0; j <= tiles; ++j )
{
subPVP.y = pvp.y + j * subPVP.h;
eq::Image* image = images[ j ];
LBCHECK( image->allocDownloader( eq::Frame::BUFFER_COLOR,
EQ_COMPRESSOR_TRANSFER_RGBA_TO_BGRA,
glewContext ));
image->clearPixelData( eq::Frame::BUFFER_COLOR );
clock.reset();
image->startReadback( eq::Frame::BUFFER_COLOR, subPVP,
eq::Zoom::NONE, glObjects );
image->finishReadback( eq::Zoom::NONE, glObjects->glewGetContext( ));
event.msec += clock.getTimef();
}
config->sendEvent( event );
if( tiles == NUM_IMAGES-1 )
for( unsigned j = 0; j <= tiles; ++j )
_saveImage( images[j],"EQ_COMPRESSOR_DATATYPE_BGRA","tiles" );
//---- benchmark assembly operations
subPVP.y = pvp.y + tiles * subPVP.h;
eq::Compositor::ImageOp op;
op.channel = this;
op.buffers = eq::Frame::BUFFER_COLOR | eq::Frame::BUFFER_DEPTH;
op.offset = offset;
// fixed-function
event.data.type = ConfigEvent::ASSEMBLE;
snprintf( event.formatType, 32, "tiles, GL1.1, %d images", tiles+1 );
clock.reset();
for( unsigned j = 0; j <= tiles; ++j )
eq::Compositor::assembleImage( images[j], op );
event.msec = clock.getTimef();
config->sendEvent( event );
// CPU
snprintf( event.formatType, 32, "tiles, CPU, %d images", tiles+1 );
std::vector< eq::Frame* > frames;
frames.push_back( &_frame );
clock.reset();
eq::Compositor::assembleFramesCPU( frames, this );
event.msec = clock.getTimef();
config->sendEvent( event );
}
}
ObjectManager::ObjectManager( const ObjectManager& shared )
: _impl( shared._impl )
{
LBASSERT( _impl );
LBASSERT( glewGetContext( ));
}
void GPUAsyncLoader::_update3DTexture()
{
if( !_storageTexture3D )
{
LBERROR << "Can't update 3D texture size - 3D texture is not initialized" << std::endl;
return;
}
if( _bytesNumNew != 1 && _bytesNumNew != 2 )
{
LBERROR << "Can't update 3D texture size - only 1 or 2 bytes per value is currently allowed" << std::endl;
return;
}
if( !_cacheIndexNew )
{
LBERROR << "GPUAsyncLoader is not initialized with _cacheIndexNew properly" << std::endl;
return;
}
if( _cacheIndex &&
*_cacheIndex == *_cacheIndexNew &&
_bytesNum == _bytesNumNew )
return;
_cacheIndex = _cacheIndexNew;
_bytesNum = _bytesNumNew;
const uint32_t blockSize = hlpFuncs::cubed( _cacheIndex->getBlockDim() );
_compressedBS = _ramPool->getDataHDDIO()->getMaxBlockSize();
_uncompressedBS = blockSize*_bytesNum;
LBWARN << "Compressed BS: " << _compressedBS << " Uncompressed BS: " << _uncompressedBS << std::endl;
LBASSERT( _compressedBS <= _uncompressedBS );
EQ_GL_CALL( glBindTexture( GL_TEXTURE_3D, _storageTexture3D ));
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_WRAP_R , GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
const Vec3_ui32 cacheDim = _cacheIndex->totalCacheTextureDim();
LBWARN << "trying to create 3D texture of the size: " << cacheDim
<< ((_bytesNum==2)?" x2 bytes":" x1 byte") << std::endl;
GLint internalFormat3D = (_bytesNum == 2) ? GL_ALPHA16 : GL_ALPHA;
_byteFormat3D = (_bytesNum == 2) ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE;
EQ_GL_CALL( glTexImage3D( GL_TEXTURE_3D,
0, internalFormat3D, cacheDim.w, cacheDim.h, cacheDim.d,
0, GL_ALPHA, _byteFormat3D, 0 ));
// init volume tree from window
Node* pipe = dynamic_cast<Node*>(getWindow()->getNode());
LBASSERT( pipe );
_volumeTree = pipe->getVolumeTree();
LBASSERT( _volumeTree );
_pbo = PboSPtr( new eq::util::PixelBufferObject( glewGetContext(), false ));
if( !_pbo->setup( _uncompressedBS, GL_WRITE_ONLY_ARB ))
LBERROR << "PBO initialization failed: " << _pbo->getError() << std::endl;
// check that PBO has proper size
_pbo->bind();
int pboSize = 0;
glGetBufferParameteriv( GL_PIXEL_UNPACK_BUFFER, GL_BUFFER_SIZE, (GLint*)&pboSize );
if( (uint32_t)pboSize != _uncompressedBS )
LBERROR << "PBO allocation failed" << std::endl;
_pbo->unbind();
_decompressor = Decompressors::select( _ramPool->getDataHDDIO(), _volumeTree, _pbo, _cacheIndex->capacity() );
EQ_GL_CALL( glFinish( ));
}
void Channel::_testTiledOperations()
{
glGetError(); // reset
//----- setup constant data
const eq::Images& images = _frame.getImages();
LBASSERT( images[0] );
const eq::PixelViewport& pvp = getPixelViewport();
const eq::Vector2i offset( pvp.x, pvp.y );
eq::Vector2i area;
area.x() = pvp.w;
lunchbox::Clock clock;
eq::util::ObjectManager& glObjects = getObjectManager();
const GLEWContext* glewContext = glewGetContext();
//----- test tiled assembly algorithms
eq::PixelViewport subPVP = pvp;
subPVP.h /= NUM_IMAGES;
for( unsigned i = 0; i < NUM_IMAGES; ++i )
{
LBASSERT( images[ i ] );
images[ i ]->setPixelViewport( subPVP );
}
for( unsigned tiles = 0; tiles < NUM_IMAGES; ++tiles )
{
EQ_GL_CALL( _draw( co::uint128_t( )));
area.y() = subPVP.h * (tiles+1);
//---- readback of 'tiles' depth images
std::stringstream formatType;
formatType << tiles+1 << " depth tiles";
float msec = 0;
for( unsigned j = 0; j <= tiles; ++j )
{
subPVP.y = pvp.y + j * subPVP.h;
eq::Image* image = images[ j ];
LBCHECK( image->allocDownloader( eq::Frame::BUFFER_DEPTH,
EQ_COMPRESSOR_TRANSFER_DEPTH_TO_DEPTH_UNSIGNED_INT,
glewContext ));
image->clearPixelData( eq::Frame::BUFFER_DEPTH );
clock.reset();
image->startReadback( eq::Frame::BUFFER_DEPTH, subPVP,
eq::Zoom::NONE, glObjects );
image->finishReadback( glObjects.glewGetContext( ));
msec += clock.getTimef();
}
_sendEvent( READBACK, msec, area, formatType.str(), 0, 0 );
if( tiles == NUM_IMAGES-1 )
for( unsigned j = 0; j <= tiles; ++j )
_saveImage( images[j],
"EQ_COMPRESSOR_DATATYPE_DEPTH_UNSIGNED_INT",
"tiles" );
//---- readback of 'tiles' color images
formatType.str("");
formatType << tiles+1 << " color tiles";
msec = 0;
for( unsigned j = 0; j <= tiles; ++j )
{
subPVP.y = pvp.y + j * subPVP.h;
eq::Image* image = images[ j ];
LBCHECK( image->allocDownloader( eq::Frame::BUFFER_COLOR,
EQ_COMPRESSOR_TRANSFER_RGBA_TO_BGRA,
glewContext ));
image->clearPixelData( eq::Frame::BUFFER_COLOR );
clock.reset();
image->startReadback( eq::Frame::BUFFER_COLOR, subPVP,
eq::Zoom::NONE, glObjects );
image->finishReadback( glObjects.glewGetContext( ));
msec += clock.getTimef();
}
_sendEvent( READBACK, msec, area, formatType.str(), 0, 0 );
if( tiles == NUM_IMAGES-1 )
for( unsigned j = 0; j <= tiles; ++j )
_saveImage( images[j],"EQ_COMPRESSOR_DATATYPE_BGRA","tiles" );
//---- benchmark assembly operations
subPVP.y = pvp.y + tiles * subPVP.h;
eq::Compositor::ImageOp op;
op.channel = this;
op.buffers = eq::Frame::BUFFER_COLOR | eq::Frame::BUFFER_DEPTH;
op.offset = offset;
// fixed-function
formatType.str("");
formatType << "tiles, GL1.1, " << tiles+1 << " images";
clock.reset();
for( unsigned j = 0; j <= tiles; ++j )
eq::Compositor::assembleImage( images[j], op );
msec = clock.getTimef();
_sendEvent( ASSEMBLE, msec, area, formatType.str(), 0, 0 );
// CPU
formatType.str("");
formatType << "tiles, CPU, " << tiles+1 << " images";
std::vector< eq::Frame* > frames;
frames.push_back( &_frame );
clock.reset();
eq::Compositor::assembleFramesCPU( frames, this );
msec = clock.getTimef();
_sendEvent( ASSEMBLE, msec, area, formatType.str(), 0, 0 );
}
}
