Welcome to mirror list, hosted at ThFree Co, Russian Federation.

git.blender.org/blender.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/intern/cycles/render/tile.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'intern/cycles/render/tile.cpp')
-rw-r--r--intern/cycles/render/tile.cpp347
1 files changed, 217 insertions, 130 deletions
diff --git a/intern/cycles/render/tile.cpp b/intern/cycles/render/tile.cpp
index 7e68ce84d94..3a6dfea11a7 100644
--- a/intern/cycles/render/tile.cpp
+++ b/intern/cycles/render/tile.cpp
@@ -21,6 +21,70 @@
CCL_NAMESPACE_BEGIN
+namespace {
+
+class TileComparator {
+public:
+ TileComparator(TileOrder order, int2 center)
+ : order_(order),
+ center_(center)
+ {}
+
+ bool operator()(Tile &a, Tile &b)
+ {
+ switch(order_) {
+ case TILE_CENTER:
+ {
+ float2 dist_a = make_float2(center_.x - (a.x + a.w/2),
+ center_.y - (a.y + a.h/2));
+ float2 dist_b = make_float2(center_.x - (b.x + b.w/2),
+ center_.y - (b.y + b.h/2));
+ return dot(dist_a, dist_a) < dot(dist_b, dist_b);
+ }
+ case TILE_LEFT_TO_RIGHT:
+ return (a.x == b.x)? (a.y < b.y): (a.x < b.x);
+ case TILE_RIGHT_TO_LEFT:
+ return (a.x == b.x)? (a.y < b.y): (a.x > b.x);
+ case TILE_TOP_TO_BOTTOM:
+ return (a.y == b.y)? (a.x < b.x): (a.y > b.y);
+ case TILE_BOTTOM_TO_TOP:
+ default:
+ return (a.y == b.y)? (a.x < b.x): (a.y < b.y);
+ }
+ }
+
+protected:
+ TileOrder order_;
+ int2 center_;
+};
+
+inline int2 hilbert_index_to_pos(int n, int d)
+{
+ int2 r, xy = make_int2(0, 0);
+ for(int s = 1; s < n; s *= 2) {
+ r.x = (d >> 1) & 1;
+ r.y = (d ^ r.x) & 1;
+ if(!r.y) {
+ if(r.x) {
+ xy = make_int2(s-1, s-1) - xy;
+ }
+ swap(xy.x, xy.y);
+ }
+ xy += r*make_int2(s, s);
+ d >>= 2;
+ }
+ return xy;
+}
+
+enum SpiralDirection {
+ DIRECTION_UP,
+ DIRECTION_LEFT,
+ DIRECTION_DOWN,
+ DIRECTION_RIGHT,
+};
+
+} /* namespace */
+
TileManager::TileManager(bool progressive_, int num_samples_, int2 tile_size_, int start_resolution_,
bool preserve_tile_device_, bool background_, TileOrder tile_order_, int num_devices_)
{
@@ -33,6 +97,9 @@ TileManager::TileManager(bool progressive_, int num_samples_, int2 tile_size_, i
preserve_tile_device = preserve_tile_device_;
background = background_;
+ range_start_sample = 0;
+ range_num_samples = -1;
+
BufferParams buffer_params;
reset(buffer_params, 0);
}
@@ -50,8 +117,8 @@ void TileManager::reset(BufferParams& params_, int num_samples_)
if(start_resolution != INT_MAX) {
while(w*h > start_resolution*start_resolution) {
- w = max(1, w/2);
- h = max(1, h/2);
+ w = max(1, w/2);
+ h = max(1, h/2);
divider *= 2;
}
@@ -60,7 +127,7 @@ void TileManager::reset(BufferParams& params_, int num_samples_)
num_samples = num_samples_;
state.buffer = BufferParams();
- state.sample = -1;
+ state.sample = range_start_sample - 1;
state.num_tiles = 0;
state.num_rendered_tiles = 0;
state.num_samples = 0;
@@ -73,74 +140,160 @@ void TileManager::set_samples(int num_samples_)
num_samples = num_samples_;
}
-/* splits image into tiles and assigns equal amount of tiles to every render device */
-void TileManager::gen_tiles_global()
+/* If sliced is false, splits image into tiles and assigns equal amount of tiles to every render device.
+ * If sliced is true, slice image into as much pieces as how many devices are rendering this image. */
+int TileManager::gen_tiles(bool sliced)
{
int resolution = state.resolution_divider;
int image_w = max(1, params.width/resolution);
int image_h = max(1, params.height/resolution);
+ int2 center = make_int2(image_w/2, image_h/2);
state.tiles.clear();
- int tile_w = (tile_size.x >= image_w)? 1: (image_w + tile_size.x - 1)/tile_size.x;
- int tile_h = (tile_size.y >= image_h)? 1: (image_h + tile_size.y - 1)/tile_size.y;
-
int num_logical_devices = preserve_tile_device? num_devices: 1;
int num = min(image_h, num_logical_devices);
+ int slice_num = sliced? num: 1;
int tile_index = 0;
- int tiles_per_device = (tile_w * tile_h + num - 1) / num;
- int cur_device = 0, cur_tiles = 0;
+ state.tiles.clear();
+ state.tiles.resize(num);
+ vector<list<Tile> >::iterator tile_list = state.tiles.begin();
- for(int tile_y = 0; tile_y < tile_h; tile_y++) {
- for(int tile_x = 0; tile_x < tile_w; tile_x++, tile_index++) {
- int x = tile_x * tile_size.x;
- int y = tile_y * tile_size.y;
- int w = (tile_x == tile_w-1)? image_w - x: tile_size.x;
- int h = (tile_y == tile_h-1)? image_h - y: tile_size.y;
+ if(tile_order == TILE_HILBERT_SPIRAL) {
+ assert(!sliced);
- state.tiles.push_back(Tile(tile_index, x, y, w, h, cur_device));
- cur_tiles++;
+ /* Size of blocks in tiles, must be a power of 2 */
+ const int hilbert_size = (max(tile_size.x, tile_size.y) <= 12)? 8: 4;
- if(cur_tiles == tiles_per_device) {
- cur_tiles = 0;
- cur_device++;
+ int tile_w = (tile_size.x >= image_w)? 1: (image_w + tile_size.x - 1)/tile_size.x;
+ int tile_h = (tile_size.y >= image_h)? 1: (image_h + tile_size.y - 1)/tile_size.y;
+ int tiles_per_device = (tile_w * tile_h + num - 1) / num;
+ int cur_device = 0, cur_tiles = 0;
+
+ int2 block_size = tile_size * make_int2(hilbert_size, hilbert_size);
+ /* Number of blocks to fill the image */
+ int blocks_x = (block_size.x >= image_w)? 1: (image_w + block_size.x - 1)/block_size.x;
+ int blocks_y = (block_size.y >= image_h)? 1: (image_h + block_size.y - 1)/block_size.y;
+ int n = max(blocks_x, blocks_y) | 0x1; /* Side length of the spiral (must be odd) */
+ /* Offset of spiral (to keep it centered) */
+ int2 offset = make_int2((image_w - n*block_size.x)/2, (image_h - n*block_size.y)/2);
+ offset = (offset / tile_size) * tile_size; /* Round to tile border. */
+
+ int2 block = make_int2(0, 0); /* Current block */
+ SpiralDirection prev_dir = DIRECTION_UP, dir = DIRECTION_UP;
+ for(int i = 0;;) {
+ /* Generate the tiles in the current block. */
+ for(int hilbert_index = 0; hilbert_index < hilbert_size*hilbert_size; hilbert_index++) {
+ int2 tile, hilbert_pos = hilbert_index_to_pos(hilbert_size, hilbert_index);
+ /* Rotate block according to spiral direction. */
+ if(prev_dir == DIRECTION_UP && dir == DIRECTION_UP) {
+ tile = make_int2(hilbert_pos.y, hilbert_pos.x);
+ }
+ else if(dir == DIRECTION_LEFT || prev_dir == DIRECTION_LEFT) {
+ tile = hilbert_pos;
+ }
+ else if(dir == DIRECTION_DOWN) {
+ tile = make_int2(hilbert_size-1-hilbert_pos.y, hilbert_size-1-hilbert_pos.x);
+ }
+ else {
+ tile = make_int2(hilbert_size-1-hilbert_pos.x, hilbert_size-1-hilbert_pos.y);
+ }
+
+ int2 pos = block*block_size + tile*tile_size + offset;
+ /* Only add tiles which are in the image (tiles outside of the image can be generated since the spiral is always square). */
+ if(pos.x >= 0 && pos.y >= 0 && pos.x < image_w && pos.y < image_h) {
+ int w = min(tile_size.x, image_w - pos.x);
+ int h = min(tile_size.y, image_h - pos.y);
+ tile_list->push_front(Tile(tile_index, pos.x, pos.y, w, h, cur_device));
+ cur_tiles++;
+ tile_index++;
+
+ if(cur_tiles == tiles_per_device) {
+ tile_list++;
+ cur_tiles = 0;
+ cur_device++;
+ }
+ }
+ }
+
+ /* Stop as soon as the spiral has reached the center block. */
+ if(block.x == (n-1)/2 && block.y == (n-1)/2)
+ break;
+
+ /* Advance to next block. */
+ prev_dir = dir;
+ switch(dir) {
+ case DIRECTION_UP:
+ block.y++;
+ if(block.y == (n-i-1)) {
+ dir = DIRECTION_LEFT;
+ }
+ break;
+ case DIRECTION_LEFT:
+ block.x++;
+ if(block.x == (n-i-1)) {
+ dir = DIRECTION_DOWN;
+ }
+ break;
+ case DIRECTION_DOWN:
+ block.y--;
+ if(block.y == i) {
+ dir = DIRECTION_RIGHT;
+ }
+ break;
+ case DIRECTION_RIGHT:
+ block.x--;
+ if(block.x == i+1) {
+ dir = DIRECTION_UP;
+ i++;
+ }
+ break;
}
}
+ return tile_index;
}
-}
-
-/* slices image into as much pieces as how many devices are rendering this image */
-void TileManager::gen_tiles_sliced()
-{
- int resolution = state.resolution_divider;
- int image_w = max(1, params.width/resolution);
- int image_h = max(1, params.height/resolution);
- state.tiles.clear();
-
- int num_logical_devices = preserve_tile_device? num_devices: 1;
- int num = min(image_h, num_logical_devices);
- int tile_index = 0;
-
- for(int device = 0; device < num; device++) {
- int device_y = (image_h/num)*device;
- int device_h = (device == num-1)? image_h - device*(image_h/num): image_h/num;
+ for(int slice = 0; slice < slice_num; slice++) {
+ int slice_y = (image_h/slice_num)*slice;
+ int slice_h = (slice == slice_num-1)? image_h - slice*(image_h/slice_num): image_h/slice_num;
int tile_w = (tile_size.x >= image_w)? 1: (image_w + tile_size.x - 1)/tile_size.x;
- int tile_h = (tile_size.y >= device_h)? 1: (device_h + tile_size.y - 1)/tile_size.y;
+ int tile_h = (tile_size.y >= slice_h)? 1: (slice_h + tile_size.y - 1)/tile_size.y;
+
+ int tiles_per_device = (tile_w * tile_h + num - 1) / num;
+ int cur_device = 0, cur_tiles = 0;
for(int tile_y = 0; tile_y < tile_h; tile_y++) {
for(int tile_x = 0; tile_x < tile_w; tile_x++, tile_index++) {
int x = tile_x * tile_size.x;
int y = tile_y * tile_size.y;
int w = (tile_x == tile_w-1)? image_w - x: tile_size.x;
- int h = (tile_y == tile_h-1)? device_h - y: tile_size.y;
-
- state.tiles.push_back(Tile(tile_index, x, y + device_y, w, h, device));
+ int h = (tile_y == tile_h-1)? slice_h - y: tile_size.y;
+
+ tile_list->push_back(Tile(tile_index, x, y + slice_y, w, h, sliced? slice: cur_device));
+
+ if(!sliced) {
+ cur_tiles++;
+
+ if(cur_tiles == tiles_per_device) {
+ /* Tiles are already generated in Bottom-to-Top order, so no sort is necessary in that case. */
+ if(tile_order != TILE_BOTTOM_TO_TOP) {
+ tile_list->sort(TileComparator(tile_order, center));
+ }
+ tile_list++;
+ cur_tiles = 0;
+ cur_device++;
+ }
+ }
}
}
+ if(sliced) {
+ tile_list++;
+ }
}
+
+ return tile_index;
}
void TileManager::set_tiles()
@@ -149,12 +302,7 @@ void TileManager::set_tiles()
int image_w = max(1, params.width/resolution);
int image_h = max(1, params.height/resolution);
- if(background)
- gen_tiles_global();
- else
- gen_tiles_sliced();
-
- state.num_tiles = state.tiles.size();
+ state.num_tiles = gen_tiles(!background);
state.buffer.width = image_w;
state.buffer.height = image_h;
@@ -165,95 +313,26 @@ void TileManager::set_tiles()
state.buffer.full_height = max(1, params.full_height/resolution);
}
-list<Tile>::iterator TileManager::next_viewport_tile(int device)
-{
- list<Tile>::iterator iter;
-
- int logical_device = preserve_tile_device? device: 0;
-
- for(iter = state.tiles.begin(); iter != state.tiles.end(); iter++) {
- if(iter->device == logical_device && iter->rendering == false)
- return iter;
- }
-
- return state.tiles.end();
-}
-
-list<Tile>::iterator TileManager::next_background_tile(int device, TileOrder tile_order)
+bool TileManager::next_tile(Tile& tile, int device)
{
- list<Tile>::iterator iter, best = state.tiles.end();
-
- int resolution = state.resolution_divider;
int logical_device = preserve_tile_device? device: 0;
- int64_t cordx = max(1, params.width/resolution);
- int64_t cordy = max(1, params.height/resolution);
- int64_t mindist = INT_MAX;
-
- int64_t centx = cordx / 2, centy = cordy / 2;
-
- for(iter = state.tiles.begin(); iter != state.tiles.end(); iter++) {
- if(iter->device == logical_device && iter->rendering == false) {
- Tile &cur_tile = *iter;
-
- int64_t distx = cordx;
- int64_t disty = cordy;
-
- switch (tile_order) {
- case TILE_CENTER:
- distx = centx - (cur_tile.x + (cur_tile.w / 2));
- disty = centy - (cur_tile.y + (cur_tile.h / 2));
- distx = (int64_t)sqrt((double)(distx * distx + disty * disty));
- break;
- case TILE_RIGHT_TO_LEFT:
- distx = cordx - cur_tile.x;
- break;
- case TILE_LEFT_TO_RIGHT:
- distx = cordx + cur_tile.x;
- break;
- case TILE_TOP_TO_BOTTOM:
- distx = cordx - cur_tile.y;
- break;
- case TILE_BOTTOM_TO_TOP:
- distx = cordx + cur_tile.y;
- break;
- default:
- break;
- }
-
- if(distx < mindist) {
- best = iter;
- mindist = distx;
- }
- }
- }
-
- return best;
-}
-
-bool TileManager::next_tile(Tile& tile, int device)
-{
- list<Tile>::iterator tile_it;
-
- if(background)
- tile_it = next_background_tile(device, tile_order);
- else
- tile_it = next_viewport_tile(device);
-
- if(tile_it != state.tiles.end()) {
- tile_it->rendering = true;
- tile = *tile_it;
- state.num_rendered_tiles++;
-
- return true;
- }
+ if((logical_device >= state.tiles.size()) || state.tiles[logical_device].empty())
+ return false;
- return false;
+ tile = Tile(state.tiles[logical_device].front());
+ state.tiles[logical_device].pop_front();
+ state.num_rendered_tiles++;
+ return true;
}
bool TileManager::done()
{
- return (state.sample+state.num_samples >= num_samples && state.resolution_divider == 1);
+ int end_sample = (range_num_samples == -1)
+ ? num_samples
+ : range_start_sample + range_num_samples;
+ return (state.resolution_divider == 1) &&
+ (state.sample+state.num_samples >= end_sample);
}
bool TileManager::next()
@@ -272,8 +351,10 @@ bool TileManager::next()
if(progressive)
state.num_samples = 1;
- else
+ else if(range_num_samples == -1)
state.num_samples = num_samples;
+ else
+ state.num_samples = range_num_samples;
state.resolution_divider = 1;
set_tiles();
@@ -282,5 +363,11 @@ bool TileManager::next()
return true;
}
+int TileManager::get_num_effective_samples()
+{
+ return (range_num_samples == -1) ? num_samples
+ : range_num_samples;
+}
+
CCL_NAMESPACE_END
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-18 11:18:10 +0300