void send_tile(
const Frame& frame,
const size_t tile_x,
const size_t tile_y) const
{
// We assume all AOV images have the same properties as the main image.
const CanvasProperties& props = frame.image().properties();
// Send beauty tile.
do_send_tile(
props,
frame.image().tile(tile_x, tile_y),
tile_x,
tile_y,
0);
if (!m_single_plane)
{
// Send AOV tiles.
for (size_t i = 0, e = frame.aov_images().size(); i < e; ++i)
{
do_send_tile(
props,
frame.aov_images().get_image(i).tile(tile_x, tile_y),
tile_x,
tile_y,
i + 1);
}
}
}
void RenderWidget::blit_tile_no_lock(
const Frame& frame,
const size_t tile_x,
const size_t tile_y,
uint8* float_tile_storage,
uint8* uint8_tile_storage)
{
// Retrieve the source tile.
const Tile& tile = frame.image().tile(tile_x, tile_y);
// Convert the tile to 32-bit floating point.
Tile fp_rgb_tile(
tile,
PixelFormatFloat,
float_tile_storage);
// Transform the tile to the color space of the frame.
frame.transform_to_output_color_space(fp_rgb_tile);
// Convert the tile to 8-bit RGB for display.
static const size_t ShuffleTable[] = { 0, 1, 2, Pixel::SkipChannel };
const Tile uint8_rgb_tile(
fp_rgb_tile,
PixelFormatUInt8,
ShuffleTable,
uint8_tile_storage);
// Retrieve destination image information.
const size_t dest_width = static_cast<size_t>(m_image.width());
const size_t dest_height = static_cast<size_t>(m_image.height());
const size_t dest_stride = static_cast<size_t>(m_image.bytesPerLine());
// Compute the coordinates of the first destination pixel.
const CanvasProperties& frame_props = frame.image().properties();
const size_t x = tile_x * frame_props.m_tile_width;
const size_t y = tile_y * frame_props.m_tile_height;
// Clipping is not supported.
assert(x < dest_width);
assert(y < dest_height);
assert(x + tile.get_width() <= dest_width);
assert(y + tile.get_height() <= dest_height);
// Get a pointer to the first destination pixel.
uint8* dest = get_image_pointer(m_image, x, y);
// Blit the tile to the destination image.
NativeDrawing::blit(dest, dest_stride, uint8_rgb_tile);
}
FrozenDisplayRenderer::FrozenDisplayRenderer(
const SamplingContext::Mode sampling_mode,
const Camera& camera,
const Frame& frame)
: m_sampling_mode(sampling_mode)
, m_camera(camera)
, m_frame(frame)
, m_frame_props(frame.image().properties())
, m_color_image(frame.image())
, m_depth_image(frame.aov_images().get_image(frame.aov_images().get_index("depth")))
, m_temp_image(m_frame_props.m_pixel_count * 4)
, m_camera_transform(camera.transform_sequence().get_earliest_transform())
, m_points(m_frame_props.m_pixel_count)
{
}
void RenderWidget::blit_frame(
const Frame& frame)
{
const CanvasProperties& frame_props = frame.image().properties();
Tile float_tile_storage(
frame_props.m_tile_width,
frame_props.m_tile_height,
frame_props.m_channel_count,
PixelFormatFloat);
Tile uint8_tile_storage(
frame_props.m_tile_width,
frame_props.m_tile_height,
frame_props.m_channel_count,
PixelFormatUInt8);
m_image_mutex.lock();
for (size_t ty = 0; ty < frame_props.m_tile_count_y; ++ty)
{
for (size_t tx = 0; tx < frame_props.m_tile_count_x; ++tx)
{
blit_tile_no_lock(
frame,
tx,
ty,
float_tile_storage.get_storage(),
uint8_tile_storage.get_storage());
}
}
m_image_mutex.unlock();
}
PermanentShadingResultFrameBufferFactory::PermanentShadingResultFrameBufferFactory(
const Frame& frame)
{
const size_t tile_count_x = frame.image().properties().m_tile_count_x;
const size_t tile_count_y = frame.image().properties().m_tile_count_y;
m_framebuffers.resize(tile_count_x * tile_count_y, 0);
}
void TileCallbackBase::post_render(const Frame& frame)
{
const CanvasProperties& frame_props = frame.image().properties();
for (size_t ty = 0; ty < frame_props.m_tile_count_y; ++ty)
{
for (size_t tx = 0; tx < frame_props.m_tile_count_x; ++tx)
post_render(frame, tx, ty);
}
}
void TileJobFactory::create(
const Frame& frame,
const TileOrdering tile_ordering,
const TileJob::TileRendererVector& tile_renderers,
const TileJob::TileCallbackVector& tile_callbacks,
const size_t pass_hash,
TileJobVector& tile_jobs,
IAbortSwitch& abort_switch)
{
// Retrieve frame properties.
const CanvasProperties& props = frame.image().properties();
// Generate tiles ordering.
vector<size_t> tiles;
generate_tile_ordering(props, tile_ordering, tiles);
// Make sure the right number of tiles was created.
assert(tiles.size() == props.m_tile_count);
// Create tile jobs, one per tile.
for (size_t i = 0; i < props.m_tile_count; ++i)
{
// Compute coordinates of the tile in the frame.
const size_t tile_index = tiles[i];
const size_t tile_x = tile_index % props.m_tile_count_x;
const size_t tile_y = tile_index / props.m_tile_count_x;
assert(tile_x < props.m_tile_count_x);
assert(tile_y < props.m_tile_count_y);
// Create the tile job.
tile_jobs.push_back(
new TileJob(
tile_renderers,
tile_callbacks,
frame,
tile_x,
tile_y,
pass_hash,
abort_switch));
}
}
void invoke_tile_callbacks(const Frame& frame)
{
if (m_tile_callback_factory)
{
// Invoke the tile callbacks on all tiles.
// todo: things would be simpler if the tile callback had a method to refresh a whole frame.
auto_release_ptr<ITileCallback> tile_callback(m_tile_callback_factory->create());
const CanvasProperties& frame_props = frame.image().properties();
for (size_t ty = 0; ty < frame_props.m_tile_count_y; ++ty)
{
for (size_t tx = 0; tx < frame_props.m_tile_count_x; ++tx)
tile_callback->on_tile_end(&frame, tx, ty);
}
// If all we have is a serial tile callback (and not a true tile callback factory), updates
// will be enqueued into the SerialRendererController instead of being executed right away,
// hence we need to manually execute them here, otherwise the render stamp is not guaranteed
// to be displayed in client applications.
if (m_serial_renderer_controller != nullptr)
m_serial_renderer_controller->exec_callbacks();
}
}
void GlobalAccumulationFramebuffer::develop_to_frame(Frame& frame) const
{
Image& image = frame.image();
const CanvasProperties& frame_props = image.properties();
assert(frame_props.m_canvas_width == m_width);
assert(frame_props.m_canvas_height == m_height);
assert(frame_props.m_channel_count == 4);
const float scale = 1.0f / m_sample_count;
for (size_t ty = 0; ty < frame_props.m_tile_count_y; ++ty)
{
for (size_t tx = 0; tx < frame_props.m_tile_count_x; ++tx)
{
Tile& tile = image.tile(tx, ty);
const size_t x = tx * frame_props.m_tile_width;
const size_t y = ty * frame_props.m_tile_height;
develop_to_tile(tile, x, y, tx, ty, scale);
}
}
}
