Sculpt: Cloth brush
[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 denoising_start_sample;
57   int pixel_size;
58   int threads;
59
60   bool use_profiling;
61
62   bool display_buffer_linear;
63
64   bool run_denoising;
65   bool write_denoising_passes;
66   bool full_denoising;
67   bool optix_denoising;
68   DenoiseParams denoising;
69
70   double cancel_timeout;
71   double reset_timeout;
72   double text_timeout;
73   double progressive_update_timeout;
74
75   ShadingSystem shadingsystem;
76
77   function<bool(const uchar *pixels, int width, int height, int channels)> write_render_cb;
78
79   SessionParams()
80   {
81     background = false;
82     progressive_refine = false;
83
84     progressive = false;
85     experimental = false;
86     samples = 1024;
87     tile_size = make_int2(64, 64);
88     start_resolution = INT_MAX;
89     denoising_start_sample = 0;
90     pixel_size = 1;
91     threads = 0;
92
93     use_profiling = false;
94
95     run_denoising = false;
96     write_denoising_passes = false;
97     full_denoising = false;
98     optix_denoising = false;
99
100     display_buffer_linear = false;
101
102     cancel_timeout = 0.1;
103     reset_timeout = 0.1;
104     text_timeout = 1.0;
105     progressive_update_timeout = 1.0;
106
107     shadingsystem = SHADINGSYSTEM_SVM;
108     tile_order = TILE_CENTER;
109   }
110
111   bool modified(const SessionParams &params)
112   {
113     return !(device == params.device && background == params.background &&
114              progressive_refine == params.progressive_refine &&
115              /* samples == params.samples && denoising_start_sample ==
116                 params.denoising_start_sample && */
117              progressive == params.progressive && experimental == params.experimental &&
118              tile_size == params.tile_size && start_resolution == params.start_resolution &&
119              pixel_size == params.pixel_size && threads == params.threads &&
120              use_profiling == params.use_profiling &&
121              display_buffer_linear == params.display_buffer_linear &&
122              cancel_timeout == params.cancel_timeout && reset_timeout == params.reset_timeout &&
123              text_timeout == params.text_timeout &&
124              progressive_update_timeout == params.progressive_update_timeout &&
125              tile_order == params.tile_order && shadingsystem == params.shadingsystem);
126   }
127 };
128
129 /* Session
130  *
131  * This is the class that contains the session thread, running the render
132  * control loop and dispatching tasks. */
133
134 class Session {
135  public:
136   Device *device;
137   Scene *scene;
138   RenderBuffers *buffers;
139   DisplayBuffer *display;
140   Progress progress;
141   SessionParams params;
142   TileManager tile_manager;
143   Stats stats;
144   Profiler profiler;
145
146   function<void(RenderTile &)> write_render_tile_cb;
147   function<void(RenderTile &, bool)> update_render_tile_cb;
148
149   explicit Session(const SessionParams &params);
150   ~Session();
151
152   void start();
153   bool draw(BufferParams &params, DeviceDrawParams &draw_params);
154   void wait();
155
156   bool ready_to_reset();
157   void reset(BufferParams &params, int samples);
158   void set_pause(bool pause);
159   void set_samples(int samples);
160   void set_denoising(bool denoising, bool optix_denoising);
161   void set_denoising_start_sample(int sample);
162
163   bool update_scene();
164   bool load_kernels(bool lock_scene = true);
165
166   void device_free();
167
168   /* Returns the rendering progress or 0 if no progress can be determined
169    * (for example, when rendering with unlimited samples). */
170   float get_progress();
171
172   void collect_statistics(RenderStats *stats);
173
174  protected:
175   struct DelayedReset {
176     thread_mutex mutex;
177     bool do_reset;
178     BufferParams params;
179     int samples;
180   } delayed_reset;
181
182   void run();
183
184   void update_status_time(bool show_pause = false, bool show_done = false);
185
186   void render(bool with_denoising);
187   void copy_to_display_buffer(int sample);
188
189   void reset_(BufferParams &params, int samples);
190
191   void run_cpu();
192   bool draw_cpu(BufferParams &params, DeviceDrawParams &draw_params);
193   void reset_cpu(BufferParams &params, int samples);
194
195   void run_gpu();
196   bool draw_gpu(BufferParams &params, DeviceDrawParams &draw_params);
197   void reset_gpu(BufferParams &params, int samples);
198
199   bool acquire_tile(RenderTile &tile, Device *tile_device, uint tile_types);
200   void update_tile_sample(RenderTile &tile);
201   void release_tile(RenderTile &tile);
202
203   void map_neighbor_tiles(RenderTile *tiles, Device *tile_device);
204   void unmap_neighbor_tiles(RenderTile *tiles, Device *tile_device);
205
206   bool device_use_gl;
207
208   thread *session_thread;
209
210   volatile bool display_outdated;
211
212   volatile bool gpu_draw_ready;
213   volatile bool gpu_need_display_buffer_update;
214   thread_condition_variable gpu_need_display_buffer_update_cond;
215
216   bool pause;
217   thread_condition_variable pause_cond;
218   thread_mutex pause_mutex;
219   thread_mutex tile_mutex;
220   thread_mutex buffers_mutex;
221   thread_mutex display_mutex;
222   thread_condition_variable denoising_cond;
223
224   bool kernels_loaded;
225   DeviceRequestedFeatures loaded_kernel_features;
226
227   double reset_time;
228   double last_update_time;
229   double last_display_time;
230
231   /* progressive refine */
232   bool update_progressive_refine(bool cancel);
233
234   DeviceRequestedFeatures get_requested_device_features();
235
236   /* ** Split kernel routines ** */
237
238   /* Maximumnumber of closure during session lifetime. */
239   int max_closure_global;
240
241   /* Get maximum number of closures to be used in kernel. */
242   int get_max_closure_count();
243 };
244
245 CCL_NAMESPACE_END
246
247 #endif /* __SESSION_H__ */