bool Channel::_isDone() const
{
const FrameData& frameData = _getFrameData();
if( !frameData.isIdle( ))
return false;
const eq::SubPixel& subpixel = getSubPixel();
const Accum& accum = _accum[ lunchbox::getIndexOfLastBit( getEye()) ];
return int32_t( subpixel.index ) >= accum.step;
}
eq::Vector2i Channel::_getJitterStep() const
{
const eq::SubPixel& subPixel = getSubPixel();
const uint32_t channelID = subPixel.index;
const View* view = static_cast< const View* >( getView( ));
if( !view )
return eq::Vector2i::ZERO;
const uint32_t totalSteps = uint32_t( view->getIdleSteps( ));
if( totalSteps != 256 )
return eq::Vector2i::ZERO;
const Accum& accum = _accum[ lunchbox::getIndexOfLastBit( getEye()) ];
const uint32_t subset = totalSteps / getSubPixel().size;
const uint32_t index = ( accum.step * _primes[ channelID % 100 ] )%subset +
( channelID * subset );
const uint32_t sampleSize = 16;
const int dx = index % sampleSize;
const int dy = index / sampleSize;
return eq::Vector2i( dx, dy );
}
/**
* Find the colors of all pixels of the job and write
* into the target image.
*
* TODO: Jitter the samples within the grid.
*
* @param job The job to render
*/
void BoundaryAdaptive::render(const RenderJob& job) {
vector<PixelBlock> blocks = vector<PixelBlock>(job.width * job.height);
// Prepare the two PixelBlock buffers
uint32_t block_size = 1 + (1 << aa_depth);
for(int i = 0; i < img_w; i++) {
row1[i].reset();
row2[i].reset();
}
std::vector<PixelBlock>* cur_row_ptr = &row1;
std::vector<PixelBlock>* prev_row_ptr = &row2;
std::vector<PixelBlock>* tmp_row_ptr;
PixelBlock* cur_block;
PixelBlock* prev_block;
RGBA color;
for (int y = job.begin_y; y < job.end_y && !aborting; y++) {
for (int x = job.begin_x; x < job.end_x && !aborting; x++) {
PixelBlock& block = blocks[(x - job.begin_x) + job.width * (y - job.begin_y)];
PixelBlock& above = blocks[(x - job.begin_x) + job.width * (y - 1 - job.begin_y)];
PixelBlock& left = blocks[(x - 1 -job.begin_x) + job.width * (y - job.begin_y)];
if (y != job.begin_y) {
block.top = above.bottom;
} else {
//block.top.add(about.bottom.first());
}
if (x != job.begin_x) {
block.left = left.right;
block.bottom.add(block.left.last);
block.bottom.add()
}
color = getSubPixel(0, Vector2(x,y), cur_block, 1.0, 0, 0, block_size - 1, block_size - 1);
setPixel(x,y,color);
}
}
void Channel::frameDraw( const eq::uint128_t& frameID )
{
if( stopRendering( ))
return;
_initJitter();
if( _isDone( ))
return;
Window* window = static_cast< Window* >( getWindow( ));
VertexBufferState& state = window->getState();
const Model* oldModel = _model;
const Model* model = _getModel();
if( oldModel != model )
state.setFrustumCulling( false ); // create all display lists/VBOs
if( model )
_updateNearFar( model->getBoundingSphere( ));
eq::Channel::frameDraw( frameID ); // Setup OpenGL state
glLightfv( GL_LIGHT0, GL_POSITION, lightPosition );
glLightfv( GL_LIGHT0, GL_AMBIENT, lightAmbient );
glLightfv( GL_LIGHT0, GL_DIFFUSE, lightDiffuse );
glLightfv( GL_LIGHT0, GL_SPECULAR, lightSpecular );
glMaterialfv( GL_FRONT, GL_AMBIENT, materialAmbient );
glMaterialfv( GL_FRONT, GL_DIFFUSE, materialDiffuse );
glMaterialfv( GL_FRONT, GL_SPECULAR, materialSpecular );
glMateriali( GL_FRONT, GL_SHININESS, materialShininess );
const FrameData& frameData = _getFrameData();
glPolygonMode( GL_FRONT_AND_BACK,
frameData.useWireframe() ? GL_LINE : GL_FILL );
const eq::Vector3f& position = frameData.getCameraPosition();
glMultMatrixf( frameData.getCameraRotation().array );
glTranslatef( position.x(), position.y(), position.z() );
glMultMatrixf( frameData.getModelRotation().array );
if( frameData.getColorMode() == COLOR_DEMO )
{
const eq::Vector3ub color = getUniqueColor();
glColor3ub( color.r(), color.g(), color.b() );
}
else
glColor3f( .75f, .75f, .75f );
if( model )
_drawModel( model );
else
{
glNormal3f( 0.f, -1.f, 0.f );
glBegin( GL_TRIANGLE_STRIP );
glVertex3f( .25f, 0.f, .25f );
glVertex3f( -.25f, 0.f, .25f );
glVertex3f( .25f, 0.f, -.25f );
glVertex3f( -.25f, 0.f, -.25f );
glEnd();
}
state.setFrustumCulling( true );
Accum& accum = _accum[ lunchbox::getIndexOfLastBit( getEye()) ];
accum.stepsDone = LB_MAX( accum.stepsDone,
getSubPixel().size * getPeriod( ));
accum.transfer = true;
}