ClangFormat: apply to source, most of intern
[blender.git] / intern / cycles / render / session.h
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #ifndef __SESSION_H__
18 #define __SESSION_H__
19
20 #include "render/buffers.h"
21 #include "device/device.h"
22 #include "render/shader.h"
23 #include "render/stats.h"
24 #include "render/tile.h"
25
26 #include "util/util_progress.h"
27 #include "util/util_stats.h"
28 #include "util/util_thread.h"
29 #include "util/util_vector.h"
30
31 CCL_NAMESPACE_BEGIN
32
33 class BufferParams;
34 class Device;
35 class DeviceScene;
36 class DeviceRequestedFeatures;
37 class DisplayBuffer;
38 class Progress;
39 class RenderBuffers;
40 class Scene;
41
42 /* Session Parameters */
43
44 class SessionParams {
45  public:
46   DeviceInfo device;
47   bool background;
48   bool progressive_refine;
49
50   bool progressive;
51   bool experimental;
52   int samples;
53   int2 tile_size;
54   TileOrder tile_order;
55   int start_resolution;
56   int pixel_size;
57   int threads;
58
59   bool use_profiling;
60
61   bool display_buffer_linear;
62
63   bool run_denoising;
64   bool write_denoising_passes;
65   bool full_denoising;
66   DenoiseParams denoising;
67
68   double cancel_timeout;
69   double reset_timeout;
70   double text_timeout;
71   double progressive_update_timeout;
72
73   ShadingSystem shadingsystem;
74
75   function<bool(const uchar *pixels, int width, int height, int channels)> write_render_cb;
76
77   SessionParams()
78   {
79     background = false;
80     progressive_refine = false;
81
82     progressive = false;
83     experimental = false;
84     samples = 1024;
85     tile_size = make_int2(64, 64);
86     start_resolution = INT_MAX;
87     pixel_size = 1;
88     threads = 0;
89
90     use_profiling = false;
91
92     run_denoising = false;
93     write_denoising_passes = false;
94     full_denoising = false;
95
96     display_buffer_linear = false;
97
98     cancel_timeout = 0.1;
99     reset_timeout = 0.1;
100     text_timeout = 1.0;
101     progressive_update_timeout = 1.0;
102
103     shadingsystem = SHADINGSYSTEM_SVM;
104     tile_order = TILE_CENTER;
105   }
106
107   bool modified(const SessionParams &params)
108   {
109     return !(device == params.device && background == params.background &&
110              progressive_refine == params.progressive_refine
111              /* && samples == params.samples */
112              && progressive == params.progressive && experimental == params.experimental &&
113              tile_size == params.tile_size && start_resolution == params.start_resolution &&
114              pixel_size == params.pixel_size && threads == params.threads &&
115              use_profiling == params.use_profiling &&
116              display_buffer_linear == params.display_buffer_linear &&
117              cancel_timeout == params.cancel_timeout && reset_timeout == params.reset_timeout &&
118              text_timeout == params.text_timeout &&
119              progressive_update_timeout == params.progressive_update_timeout &&
120              tile_order == params.tile_order && shadingsystem == params.shadingsystem);
121   }
122 };
123
124 /* Session
125  *
126  * This is the class that contains the session thread, running the render
127  * control loop and dispatching tasks. */
128
129 class Session {
130  public:
131   Device *device;
132   Scene *scene;
133   RenderBuffers *buffers;
134   DisplayBuffer *display;
135   Progress progress;
136   SessionParams params;
137   TileManager tile_manager;
138   Stats stats;
139   Profiler profiler;
140
141   function<void(RenderTile &)> write_render_tile_cb;
142   function<void(RenderTile &, bool)> update_render_tile_cb;
143
144   explicit Session(const SessionParams &params);
145   ~Session();
146
147   void start();
148   bool draw(BufferParams &params, DeviceDrawParams &draw_params);
149   void wait();
150
151   bool ready_to_reset();
152   void reset(BufferParams &params, int samples);
153   void set_samples(int samples);
154   void set_pause(bool pause);
155
156   bool update_scene();
157   bool load_kernels(bool lock_scene = true);
158
159   void device_free();
160
161   /* Returns the rendering progress or 0 if no progress can be determined
162    * (for example, when rendering with unlimited samples). */
163   float get_progress();
164
165   void collect_statistics(RenderStats *stats);
166
167  protected:
168   struct DelayedReset {
169     thread_mutex mutex;
170     bool do_reset;
171     BufferParams params;
172     int samples;
173   } delayed_reset;
174
175   void run();
176
177   void update_status_time(bool show_pause = false, bool show_done = false);
178
179   void tonemap(int sample);
180   void render();
181   void reset_(BufferParams &params, int samples);
182
183   void run_cpu();
184   bool draw_cpu(BufferParams &params, DeviceDrawParams &draw_params);
185   void reset_cpu(BufferParams &params, int samples);
186
187   void run_gpu();
188   bool draw_gpu(BufferParams &params, DeviceDrawParams &draw_params);
189   void reset_gpu(BufferParams &params, int samples);
190
191   bool acquire_tile(Device *tile_device, RenderTile &tile);
192   void update_tile_sample(RenderTile &tile);
193   void release_tile(RenderTile &tile);
194
195   void map_neighbor_tiles(RenderTile *tiles, Device *tile_device);
196   void unmap_neighbor_tiles(RenderTile *tiles, Device *tile_device);
197
198   bool device_use_gl;
199
200   thread *session_thread;
201
202   volatile bool display_outdated;
203
204   volatile bool gpu_draw_ready;
205   volatile bool gpu_need_tonemap;
206   thread_condition_variable gpu_need_tonemap_cond;
207
208   bool pause;
209   thread_condition_variable pause_cond;
210   thread_mutex pause_mutex;
211   thread_mutex tile_mutex;
212   thread_mutex buffers_mutex;
213   thread_mutex display_mutex;
214
215   bool kernels_loaded;
216   DeviceRequestedFeatures loaded_kernel_features;
217
218   double reset_time;
219
220   /* progressive refine */
221   double last_update_time;
222   bool update_progressive_refine(bool cancel);
223
224   DeviceRequestedFeatures get_requested_device_features();
225
226   /* ** Split kernel routines ** */
227
228   /* Maximumnumber of closure during session lifetime. */
229   int max_closure_global;
230
231   /* Get maximum number of closures to be used in kernel. */
232   int get_max_closure_count();
233 };
234
235 CCL_NAMESPACE_END
236
237 #endif /* __SESSION_H__ */