Page MenuHome
Differential D1166 Diff 5640 intern/cycles/render/tile.cpp

Changeset View

Standalone View

View Options

intern/cycles/render/tile.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Linesprotected:
TileOrder order_; TileOrder order_;
int2 center_; int2 center_;
}; };
} /* namespace */ } /* namespace */
TileManager::TileManager(bool progressive_, int num_samples_, int2 tile_size_, int start_resolution_, 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_) bool preserve_tile_device_, bool background_, TileOrder tile_order_, int num_devices_)
{ {
sergeyUnsubmitted
Not Done
Inline Actions

d >> 1

sergey: `d >> 1`
progressive = progressive_; progressive = progressive_;
tile_size = tile_size_; tile_size = tile_size_;
tile_order = tile_order_; tile_order = tile_order_;
start_resolution = start_resolution_; start_resolution = start_resolution_;
sergeyUnsubmitted
Not Done
Inline Actions

Braces.

sergey: Braces.
num_samples = num_samples_; num_samples = num_samples_;
num_devices = num_devices_; num_devices = num_devices_;
preserve_tile_device = preserve_tile_device_; preserve_tile_device = preserve_tile_device_;
background = background_; background = background_;
sergeyUnsubmitted
Not Done
Inline Actions

d >>= 2

sergey: `d >>= 2`
BufferParams buffer_params; BufferParams buffer_params;
reset(buffer_params, 0); reset(buffer_params, 0);
} }
TileManager::~TileManager() TileManager::~TileManager()
{ {
} }
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint TileManager::gen_tiles(bool sliced)
int num = min(image_h, num_logical_devices); int num = min(image_h, num_logical_devices);
int slice_num = sliced? num: 1; int slice_num = sliced? num: 1;
int tile_index = 0; int tile_index = 0;
state.tiles.clear(); state.tiles.clear();
state.tiles.resize(num); state.tiles.resize(num);
vector<list<Tile> >::iterator tile_list = state.tiles.begin(); vector<list<Tile> >::iterator tile_list = state.tiles.begin();
if(tile_order == TILE_HILBERT_SPIRAL) {
assert(!sliced);
sergeyUnsubmitted
Not Done
Inline Actions

This will fail for viewport renders, i.e.

sergey: This will fail for viewport renders, i.e.
const int hilbert_size = 4; /* Size of blocks in tiles, must be a power of 2 */
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) */
int2 o = make_int2((image_w - n*block_size.x)/2, (image_h - n*block_size.y)/2); /* Offset of spiral (to keep it centered) */
sergeyUnsubmitted
Not Done
Inline Actions

Can it be more meaningful name than just a single letter? Same applies to the cases below.

sergey: Can it be more meaningful name than just a single letter? Same applies to the cases below.
o = (o / tile_size) * tile_size; /* Round to tile border */
int2 b = make_int2(0, 0);
int pdir = 0, dir = 0;
for(int i = 0;;) {
sergeyUnsubmitted
Not Done
Inline Actions

Can we have more readable names for the direction? Like,

enum {
  DIRECTION_LEFT,
  DIRECTION_TOP,
};

or something similar?

sergey: Can we have more readable names for the direction? Like, enum { DIRECTION_LEFT…
if((b.x*block_size.x+o.x < image_w) && (b.y*block_size.y+o.y < image_h) &&
((b.x+1)*block_size.x+o.x > 0) && ((b.y+1)*block_size.y+o.y > 0)) {
for(int ti = 0; ti < hilbert_size*hilbert_size; ti++) {
int2 t, h = hilbert_to_pos(hilbert_size, ti);
if(pdir == 0 && dir == 0)
t = make_int2(h.y, h.x);
sergeyUnsubmitted
Not Done
Inline Actions

Braces around the block.

sergey: Braces around the block.
else if(dir == 1 || pdir == 1)
t = h;
else if(dir == 2)
t = make_int2(hilbert_size-1-h.y, hilbert_size-1-h.x);
else
t = make_int2(hilbert_size-1-h.x, hilbert_size-1-h.y);
int2 p = b*block_size + t*tile_size + o;
if(p.x >= 0 && p.y >= 0 && p.x < image_w && p.y < image_h) {
int w = min(tile_size.x, image_w - p.x);
int h = min(tile_size.y, image_h - p.y);
tile_list->push_front(Tile(tile_index, p.x, p.y, w, h, cur_device));
cur_tiles++;
tile_index++;
if(cur_tiles == tiles_per_device) {
tile_list++;
cur_tiles = 0;
cur_device++;
}
}
}
}
pdir = dir;
if(b.x == (n-1)/2 && b.y == (n-1)/2)
break;
switch(dir) {
case 0:
b.y++;
if(b.y == (n-i-1)) dir = 1;
break;
sergeyUnsubmitted
Not Done
Inline Actions

Picky: Prefer not to have quesitons in comments, statements are usually cleaner to follow. Like, "Check whether center of spiral was reached.". Applies to few places here.

sergey: Picky: Prefer not to have quesitons in comments, statements are usually cleaner to follow. Like…
case 1:
b.x++;
if(b.x == (n-i-1)) dir = 2;
break;
case 2:
b.y--;
if(b.y == i) dir = 3;
sergeyUnsubmitted
Not Done
Inline Actions

This doesn't follow code style.

sergey: This doesn't follow code style.
break;
sergeyUnsubmitted
Not Done
Inline Actions

Could also become an util_ function.

sergey: Could also become an util_ function.
case 3:
b.x--;
if(b.x == i+1) {
dir = 0;
i++;
}
break;
}
}
return tile_index;
}
for(int slice = 0; slice < slice_num; slice++) { for(int slice = 0; slice < slice_num; slice++) {
int slice_y = (image_h/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 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_w = (tile_size.x >= image_w)? 1: (image_w + tile_size.x - 1)/tile_size.x;
int tile_h = (tile_size.y >= slice_h)? 1: (slice_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 tiles_per_device = (tile_w * tile_h + num - 1) / num;
int cur_device = 0, cur_tiles = 0; int cur_device = 0, cur_tiles = 0;
for(int tile_y = 0; tile_y < tile_h; tile_y++) { for(int tile_y = 0; tile_y < tile_h; tile_y++) {
for(int tile_x = 0; tile_x < tile_w; tile_x++, tile_index++) { for(int tile_x = 0; tile_x < tile_w; tile_x++, tile_index++) {
int x = tile_x * tile_size.x; int x = tile_x * tile_size.x;
int y = tile_y * tile_size.y; int y = tile_y * tile_size.y;
int w = (tile_x == tile_w-1)? image_w - x: tile_size.x; int w = (tile_x == tile_w-1)? image_w - x: tile_size.x;
int h = (tile_y == tile_h-1)? slice_h - y: tile_size.y; 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)); tile_list->push_back(Tile(tile_index, x, y + slice_y, w, h, sliced? slice: cur_device));
if(!sliced) { if(!sliced) {
cur_tiles++; cur_tiles++;
if(cur_tiles == tiles_per_device) { if(cur_tiles == tiles_per_device) {
tile_list->sort(TileComparator(tile_order, center)); tile_list->sort(TileComparator(tile_order, center));
tile_list++; tile_list++;
sergeyUnsubmitted
Not Done
Inline Actions

Please apply this separately. Can go to master now, but please always use mustage (curly ;) brackets.

sergey: Please apply this separately. Can go to master now, but please always use mustage (curly ;)…
cur_tiles = 0; cur_tiles = 0;
cur_device++; cur_device++;
} }
} }
} }
} }
} }
Show All 12 Linesvoid TileManager::set_tiles()
state.buffer.height = image_h; state.buffer.height = image_h;
state.buffer.full_x = params.full_x/resolution; state.buffer.full_x = params.full_x/resolution;
state.buffer.full_y = params.full_y/resolution; state.buffer.full_y = params.full_y/resolution;
state.buffer.full_width = max(1, params.full_width/resolution); state.buffer.full_width = max(1, params.full_width/resolution);
state.buffer.full_height = max(1, params.full_height/resolution); state.buffer.full_height = max(1, params.full_height/resolution);
} }
bool TileManager::next_tile(Tile& tile, int device) bool TileManager::next_tile(Tile& tile, int device)
sergeyUnsubmitted
Not Done
Inline Actions

This is to be calculated for only TILE_HILBERT it seems, no need to calculate it for all the tile orders.

sergey: This is to be calculated for only `TILE_HILBERT` it seems, no need to calculate it for all the…
{ {
int logical_device = preserve_tile_device? device: 0; int logical_device = preserve_tile_device? device: 0;
if((logical_device >= state.tiles.size()) || state.tiles[logical_device].empty()) if((logical_device >= state.tiles.size()) || state.tiles[logical_device].empty())
return false; return false;
tile = Tile(state.tiles[logical_device].front()); tile = Tile(state.tiles[logical_device].front());
state.tiles[logical_device].pop_front(); state.tiles[logical_device].pop_front();
Show All 37 Lines