2011-04-27 11:58:34 +00:00
|
|
|
/*
|
2013-08-18 14:16:15 +00:00
|
|
|
* Copyright 2011-2013 Blender Foundation
|
2011-04-27 11:58:34 +00:00
|
|
|
*
|
2013-08-18 14:16:15 +00:00
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
2011-04-27 11:58:34 +00:00
|
|
|
*
|
2013-08-18 14:16:15 +00:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2011-04-27 11:58:34 +00:00
|
|
|
*
|
2013-08-18 14:16:15 +00:00
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
2014-12-25 01:50:24 +00:00
|
|
|
* limitations under the License.
|
2011-04-27 11:58:34 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __TILE_H__
|
|
|
|
#define __TILE_H__
|
|
|
|
|
|
|
|
#include <limits.h>
|
|
|
|
|
Cycles: Make all #include statements relative to cycles source directory
The idea is to make include statements more explicit and obvious where the
file is coming from, additionally reducing chance of wrong header being
picked up.
For example, it was not obvious whether bvh.h was refferring to builder
or traversal, whenter node.h is a generic graph node or a shader node
and cases like that.
Surely this might look obvious for the active developers, but after some
time of not touching the code it becomes less obvious where file is coming
from.
This was briefly mentioned in T50824 and seems @brecht is fine with such
explicitness, but need to agree with all active developers before committing
this.
Please note that this patch is lacking changes related on GPU/OpenCL
support. This will be solved if/when we all agree this is a good idea to move
forward.
Reviewers: brecht, lukasstockner97, maiself, nirved, dingto, juicyfruit, swerner
Reviewed By: lukasstockner97, maiself, nirved, dingto
Subscribers: brecht
Differential Revision: https://developer.blender.org/D2586
2017-03-28 18:39:14 +00:00
|
|
|
#include "render/buffers.h"
|
|
|
|
#include "util/util_list.h"
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
|
|
|
|
/* Tile */
|
|
|
|
|
|
|
|
class Tile {
|
|
|
|
public:
|
2012-10-23 16:36:53 +00:00
|
|
|
int index;
|
2011-04-27 11:58:34 +00:00
|
|
|
int x, y, w, h;
|
2012-09-04 13:29:07 +00:00
|
|
|
int device;
|
2017-05-07 12:40:58 +00:00
|
|
|
/* RENDER: The tile has to be rendered.
|
|
|
|
* RENDERED: The tile has been rendered, but can't be denoised yet (waiting for neighbors).
|
|
|
|
* DENOISE: The tile can be denoised now.
|
|
|
|
* DENOISED: The tile has been denoised, but can't be freed yet (waiting for neighbors).
|
|
|
|
* DONE: The tile is finished and has been freed. */
|
|
|
|
typedef enum { RENDER = 0, RENDERED, DENOISE, DENOISED, DONE } State;
|
|
|
|
State state;
|
|
|
|
RenderBuffers *buffers;
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2012-09-04 13:29:07 +00:00
|
|
|
Tile()
|
|
|
|
{
|
|
|
|
}
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2017-05-07 12:40:58 +00:00
|
|
|
Tile(int index_, int x_, int y_, int w_, int h_, int device_, State state_ = RENDER)
|
|
|
|
: index(index_), x(x_), y(y_), w(w_), h(h_), device(device_), state(state_), buffers(NULL)
|
|
|
|
{
|
|
|
|
}
|
2011-04-27 11:58:34 +00:00
|
|
|
};
|
|
|
|
|
2013-09-03 22:39:21 +00:00
|
|
|
/* Tile order */
|
|
|
|
|
|
|
|
/* Note: this should match enum_tile_order in properties.py */
|
|
|
|
enum TileOrder {
|
|
|
|
TILE_CENTER = 0,
|
|
|
|
TILE_RIGHT_TO_LEFT = 1,
|
|
|
|
TILE_LEFT_TO_RIGHT = 2,
|
|
|
|
TILE_TOP_TO_BOTTOM = 3,
|
Cycles: Adding Hilbert Spiral as a tile order for rendering
This patch adds the "Hilbert Spiral", a custom-designed continuous space-filling curve, as a tile order for rendering in Cycles.
It essentially works by dividing the tiles into tile blocks which are processed in a spiral outwards from the center. Inside each
block, the tiles are processed in a regular Hilbert curve pattern. By rotating that pattern according to the spiral direction,
a continuous curve is obtained, which helps with cache coherency and therefore rendering speed.
The curve is a compromise between the faster-rendering Bottom-to-Top etc. orders and the Center order, which is a bit slower,
but starts with the more important areas. The Hilbert Spiral also starts in the center (unless huge tiles are used) and is still
marginally slower than Bottom-to-Top, but noticeably faster than Center.
Reviewers: sergey, #cycles, dingto
Reviewed By: #cycles, dingto
Subscribers: iscream, gregzaal, sergey, mib2berlin
Differential Revision: https://developer.blender.org/D1166
2016-01-09 23:11:34 +00:00
|
|
|
TILE_BOTTOM_TO_TOP = 4,
|
|
|
|
TILE_HILBERT_SPIRAL = 5,
|
2013-09-03 22:39:21 +00:00
|
|
|
};
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
/* Tile Manager */
|
|
|
|
|
|
|
|
class TileManager {
|
|
|
|
public:
|
2011-12-20 12:25:37 +00:00
|
|
|
BufferParams params;
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
struct State {
|
2017-05-07 12:40:58 +00:00
|
|
|
vector<Tile> tiles;
|
|
|
|
int tile_stride;
|
2011-12-21 13:48:35 +00:00
|
|
|
BufferParams buffer;
|
2011-09-16 13:14:02 +00:00
|
|
|
int sample;
|
2012-09-04 13:29:07 +00:00
|
|
|
int num_samples;
|
2012-09-17 10:55:18 +00:00
|
|
|
int resolution_divider;
|
2012-09-04 13:29:07 +00:00
|
|
|
int num_tiles;
|
2019-04-17 04:17:24 +00:00
|
|
|
|
Cycles: Refactor Progress system to provide better estimates
The Progress system in Cycles had two limitations so far:
- It just counted tiles, but ignored their size. For example, when rendering a 600x500 image with 512x512 tiles, the right 88x500 tile would count for 50% of the progress, although it only covers 15% of the image.
- Scene update time was incorrectly counted as rendering time - therefore, the remaining time started very long and gradually decreased.
This patch fixes both problems:
First of all, the Progress now has a function to ignore time spans, and that is used to ignore scene update time.
The larger change is the tile size: Instead of counting samples per tile, so that the final value is num_samples*num_tiles, the code now counts every sample for every pixel, so that the final value is num_samples*num_pixels.
Along with that, some unused variables were removed from the Progress and Session classes.
Reviewers: brecht, sergey, #cycles
Subscribers: brecht, candreacchio, sergey
Differential Revision: https://developer.blender.org/D2214
2016-11-26 03:22:34 +00:00
|
|
|
/* Total samples over all pixels: Generally num_samples*num_pixels,
|
|
|
|
* but can be higher due to the initial resolution division for previews. */
|
|
|
|
uint64_t total_pixel_samples;
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2017-05-07 12:40:58 +00:00
|
|
|
/* These lists contain the indices of the tiles to be rendered/denoised and are used
|
|
|
|
* when acquiring a new tile for the device.
|
|
|
|
* Each list in each vector is for one logical device. */
|
|
|
|
vector<list<int>> render_tiles;
|
|
|
|
vector<list<int>> denoising_tiles;
|
2011-04-27 11:58:34 +00:00
|
|
|
} state;
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2013-04-05 17:57:26 +00:00
|
|
|
int num_samples;
|
2020-02-11 15:30:01 +00:00
|
|
|
int slice_overlap;
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2012-10-23 16:36:53 +00:00
|
|
|
TileManager(bool progressive,
|
|
|
|
int num_samples,
|
|
|
|
int2 tile_size,
|
|
|
|
int start_resolution,
|
2017-08-14 22:11:52 +00:00
|
|
|
bool preserve_tile_device,
|
|
|
|
bool background,
|
|
|
|
TileOrder tile_order,
|
|
|
|
int num_devices = 1,
|
|
|
|
int pixel_size = 1);
|
2011-04-27 11:58:34 +00:00
|
|
|
~TileManager();
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2017-10-10 00:28:23 +00:00
|
|
|
void device_free();
|
2012-09-04 13:29:07 +00:00
|
|
|
void reset(BufferParams ¶ms, int num_samples);
|
|
|
|
void set_samples(int num_samples);
|
2011-04-27 11:58:34 +00:00
|
|
|
bool next();
|
2020-02-26 15:30:42 +00:00
|
|
|
bool next_tile(Tile *&tile, int device, uint tile_types);
|
2020-04-28 18:27:03 +00:00
|
|
|
bool finish_tile(const int index, const bool need_denoise, bool &delete_tile);
|
2011-04-27 11:58:34 +00:00
|
|
|
bool done();
|
2020-02-11 15:30:01 +00:00
|
|
|
bool has_tiles();
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2013-09-03 22:39:21 +00:00
|
|
|
void set_tile_order(TileOrder tile_order_)
|
|
|
|
{
|
|
|
|
tile_order = tile_order_;
|
|
|
|
}
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2020-02-11 15:30:01 +00:00
|
|
|
int get_neighbor_index(int index, int neighbor);
|
|
|
|
bool check_neighbor_state(int index, Tile::State state);
|
|
|
|
|
2016-03-30 13:55:12 +00:00
|
|
|
/* ** Sample range rendering. ** */
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2016-03-30 13:55:12 +00:00
|
|
|
/* Start sample in the range. */
|
|
|
|
int range_start_sample;
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2016-03-30 13:55:12 +00:00
|
|
|
/* Number to samples in the rendering range. */
|
|
|
|
int range_num_samples;
|
2019-04-17 04:17:24 +00:00
|
|
|
|
Cycles: Refactor Progress system to provide better estimates
The Progress system in Cycles had two limitations so far:
- It just counted tiles, but ignored their size. For example, when rendering a 600x500 image with 512x512 tiles, the right 88x500 tile would count for 50% of the progress, although it only covers 15% of the image.
- Scene update time was incorrectly counted as rendering time - therefore, the remaining time started very long and gradually decreased.
This patch fixes both problems:
First of all, the Progress now has a function to ignore time spans, and that is used to ignore scene update time.
The larger change is the tile size: Instead of counting samples per tile, so that the final value is num_samples*num_tiles, the code now counts every sample for every pixel, so that the final value is num_samples*num_pixels.
Along with that, some unused variables were removed from the Progress and Session classes.
Reviewers: brecht, sergey, #cycles
Subscribers: brecht, candreacchio, sergey
Differential Revision: https://developer.blender.org/D2214
2016-11-26 03:22:34 +00:00
|
|
|
/* Get number of actual samples to render. */
|
2016-03-30 13:55:12 +00:00
|
|
|
int get_num_effective_samples();
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2017-05-07 12:40:58 +00:00
|
|
|
/* Schedule tiles for denoising after they've been rendered. */
|
|
|
|
bool schedule_denoising;
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2013-09-03 22:39:21 +00:00
|
|
|
protected:
|
2011-04-27 11:58:34 +00:00
|
|
|
void set_tiles();
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
bool progressive;
|
2012-09-04 13:29:07 +00:00
|
|
|
int2 tile_size;
|
2013-09-03 22:39:21 +00:00
|
|
|
TileOrder tile_order;
|
2011-04-27 11:58:34 +00:00
|
|
|
int start_resolution;
|
2017-08-14 22:11:52 +00:00
|
|
|
int pixel_size;
|
2012-09-17 10:55:18 +00:00
|
|
|
int num_devices;
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2012-10-23 16:36:53 +00:00
|
|
|
/* in some cases it is important that the same tile will be returned for the same
|
|
|
|
* device it was originally generated for (i.e. viewport rendering when buffer is
|
|
|
|
* allocating once for tile and then always used by it)
|
|
|
|
*
|
|
|
|
* in other cases any tile could be handled by any device (i.e. final rendering
|
|
|
|
* without progressive refine)
|
|
|
|
*/
|
|
|
|
bool preserve_tile_device;
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2012-10-24 14:43:29 +00:00
|
|
|
/* for background render tiles should exactly match render parts generated from
|
|
|
|
* blender side, which means image first gets split into tiles and then tiles are
|
|
|
|
* assigning to render devices
|
|
|
|
*
|
|
|
|
* however viewport rendering expects tiles to be allocated in a special way,
|
|
|
|
* meaning image is being sliced horizontally first and every device handles
|
|
|
|
* its own slice
|
|
|
|
*/
|
|
|
|
bool background;
|
2019-04-17 04:17:24 +00:00
|
|
|
|
2015-12-22 11:51:27 +00:00
|
|
|
/* Generate tile list, return number of tiles. */
|
|
|
|
int gen_tiles(bool sliced);
|
2017-10-10 00:28:23 +00:00
|
|
|
void gen_render_tiles();
|
2011-04-27 11:58:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
CCL_NAMESPACE_END
|
|
|
|
|
|
|
|
#endif /* __TILE_H__ */
|