GPencil: Fix unreported unable to deselect when masking is OFF
[blender.git] / intern / cycles / device / device.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 __DEVICE_H__
18 #define __DEVICE_H__
19
20 #include <stdlib.h>
21
22 #include "bvh/bvh_params.h"
23
24 #include "device/device_memory.h"
25 #include "device/device_task.h"
26
27 #include "util/util_list.h"
28 #include "util/util_stats.h"
29 #include "util/util_string.h"
30 #include "util/util_thread.h"
31 #include "util/util_texture.h"
32 #include "util/util_types.h"
33 #include "util/util_vector.h"
34
35 CCL_NAMESPACE_BEGIN
36
37 class Progress;
38 class RenderTile;
39
40 /* Device Types */
41
42 enum DeviceType {
43   DEVICE_NONE = 0,
44   DEVICE_CPU,
45   DEVICE_OPENCL,
46   DEVICE_CUDA,
47   DEVICE_NETWORK,
48   DEVICE_MULTI
49 };
50
51 enum DeviceTypeMask {
52   DEVICE_MASK_CPU = (1 << DEVICE_CPU),
53   DEVICE_MASK_OPENCL = (1 << DEVICE_OPENCL),
54   DEVICE_MASK_CUDA = (1 << DEVICE_CUDA),
55   DEVICE_MASK_NETWORK = (1 << DEVICE_NETWORK),
56   DEVICE_MASK_ALL = ~0
57 };
58
59 enum DeviceKernelStatus {
60   DEVICE_KERNEL_WAITING_FOR_FEATURE_KERNEL = 0,
61   DEVICE_KERNEL_FEATURE_KERNEL_AVAILABLE,
62   DEVICE_KERNEL_USING_FEATURE_KERNEL,
63   DEVICE_KERNEL_FEATURE_KERNEL_INVALID,
64   DEVICE_KERNEL_UNKNOWN,
65 };
66
67 #define DEVICE_MASK(type) (DeviceTypeMask)(1 << type)
68
69 class DeviceInfo {
70  public:
71   DeviceType type;
72   string description;
73   string id; /* used for user preferences, should stay fixed with changing hardware config */
74   int num;
75   bool display_device;       /* GPU is used as a display device. */
76   bool has_half_images;      /* Support half-float textures. */
77   bool has_volume_decoupled; /* Decoupled volume shading. */
78   bool has_osl;              /* Support Open Shading Language. */
79   bool use_split_kernel;     /* Use split or mega kernel. */
80   bool has_profiling;        /* Supports runtime collection of profiling info. */
81   int cpu_threads;
82   vector<DeviceInfo> multi_devices;
83
84   DeviceInfo()
85   {
86     type = DEVICE_CPU;
87     id = "CPU";
88     num = 0;
89     cpu_threads = 0;
90     display_device = false;
91     has_half_images = false;
92     has_volume_decoupled = false;
93     has_osl = false;
94     use_split_kernel = false;
95     has_profiling = false;
96   }
97
98   bool operator==(const DeviceInfo &info)
99   {
100     /* Multiple Devices with the same ID would be very bad. */
101     assert(id != info.id ||
102            (type == info.type && num == info.num && description == info.description));
103     return id == info.id;
104   }
105 };
106
107 class DeviceRequestedFeatures {
108  public:
109   /* Use experimental feature set. */
110   bool experimental;
111
112   /* Selective nodes compilation. */
113
114   /* Identifier of a node group up to which all the nodes needs to be
115    * compiled in. Nodes from higher group indices will be ignores.
116    */
117   int max_nodes_group;
118
119   /* Features bitfield indicating which features from the requested group
120    * will be compiled in. Nodes which corresponds to features which are not
121    * in this bitfield will be ignored even if they're in the requested group.
122    */
123   int nodes_features;
124
125   /* BVH/sampling kernel features. */
126   bool use_hair;
127   bool use_object_motion;
128   bool use_camera_motion;
129
130   /* Denotes whether baking functionality is needed. */
131   bool use_baking;
132
133   /* Use subsurface scattering materials. */
134   bool use_subsurface;
135
136   /* Use volume materials. */
137   bool use_volume;
138
139   /* Use branched integrator. */
140   bool use_integrator_branched;
141
142   /* Use OpenSubdiv patch evaluation */
143   bool use_patch_evaluation;
144
145   /* Use Transparent shadows */
146   bool use_transparent;
147
148   /* Use various shadow tricks, such as shadow catcher. */
149   bool use_shadow_tricks;
150
151   /* Per-uber shader usage flags. */
152   bool use_principled;
153
154   /* Denoising features. */
155   bool use_denoising;
156
157   /* Use raytracing in shaders. */
158   bool use_shader_raytrace;
159
160   /* Use true displacement */
161   bool use_true_displacement;
162
163   /* Use background lights */
164   bool use_background_light;
165
166   DeviceRequestedFeatures()
167   {
168     /* TODO(sergey): Find more meaningful defaults. */
169     experimental = false;
170     max_nodes_group = 0;
171     nodes_features = 0;
172     use_hair = false;
173     use_object_motion = false;
174     use_camera_motion = false;
175     use_baking = false;
176     use_subsurface = false;
177     use_volume = false;
178     use_integrator_branched = false;
179     use_patch_evaluation = false;
180     use_transparent = false;
181     use_shadow_tricks = false;
182     use_principled = false;
183     use_denoising = false;
184     use_shader_raytrace = false;
185     use_true_displacement = false;
186     use_background_light = false;
187   }
188
189   bool modified(const DeviceRequestedFeatures &requested_features)
190   {
191     return !(experimental == requested_features.experimental &&
192              max_nodes_group == requested_features.max_nodes_group &&
193              nodes_features == requested_features.nodes_features &&
194              use_hair == requested_features.use_hair &&
195              use_object_motion == requested_features.use_object_motion &&
196              use_camera_motion == requested_features.use_camera_motion &&
197              use_baking == requested_features.use_baking &&
198              use_subsurface == requested_features.use_subsurface &&
199              use_volume == requested_features.use_volume &&
200              use_integrator_branched == requested_features.use_integrator_branched &&
201              use_patch_evaluation == requested_features.use_patch_evaluation &&
202              use_transparent == requested_features.use_transparent &&
203              use_shadow_tricks == requested_features.use_shadow_tricks &&
204              use_principled == requested_features.use_principled &&
205              use_denoising == requested_features.use_denoising &&
206              use_shader_raytrace == requested_features.use_shader_raytrace &&
207              use_true_displacement == requested_features.use_true_displacement &&
208              use_background_light == requested_features.use_background_light);
209   }
210
211   /* Convert the requested features structure to a build options,
212    * which could then be passed to compilers.
213    */
214   string get_build_options() const
215   {
216     string build_options = "";
217     if (experimental) {
218       build_options += "-D__KERNEL_EXPERIMENTAL__ ";
219     }
220     build_options += "-D__NODES_MAX_GROUP__=" + string_printf("%d", max_nodes_group);
221     build_options += " -D__NODES_FEATURES__=" + string_printf("%d", nodes_features);
222     if (!use_hair) {
223       build_options += " -D__NO_HAIR__";
224     }
225     if (!use_object_motion) {
226       build_options += " -D__NO_OBJECT_MOTION__";
227     }
228     if (!use_camera_motion) {
229       build_options += " -D__NO_CAMERA_MOTION__";
230     }
231     if (!use_baking) {
232       build_options += " -D__NO_BAKING__";
233     }
234     if (!use_volume) {
235       build_options += " -D__NO_VOLUME__";
236     }
237     if (!use_subsurface) {
238       build_options += " -D__NO_SUBSURFACE__";
239     }
240     if (!use_integrator_branched) {
241       build_options += " -D__NO_BRANCHED_PATH__";
242     }
243     if (!use_patch_evaluation) {
244       build_options += " -D__NO_PATCH_EVAL__";
245     }
246     if (!use_transparent && !use_volume) {
247       build_options += " -D__NO_TRANSPARENT__";
248     }
249     if (!use_shadow_tricks) {
250       build_options += " -D__NO_SHADOW_TRICKS__";
251     }
252     if (!use_principled) {
253       build_options += " -D__NO_PRINCIPLED__";
254     }
255     if (!use_denoising) {
256       build_options += " -D__NO_DENOISING__";
257     }
258     if (!use_shader_raytrace) {
259       build_options += " -D__NO_SHADER_RAYTRACE__";
260     }
261     return build_options;
262   }
263 };
264
265 std::ostream &operator<<(std::ostream &os, const DeviceRequestedFeatures &requested_features);
266
267 /* Device */
268
269 struct DeviceDrawParams {
270   function<void()> bind_display_space_shader_cb;
271   function<void()> unbind_display_space_shader_cb;
272 };
273
274 class Device {
275   friend class device_sub_ptr;
276
277  protected:
278   enum {
279     FALLBACK_SHADER_STATUS_NONE = 0,
280     FALLBACK_SHADER_STATUS_ERROR,
281     FALLBACK_SHADER_STATUS_SUCCESS,
282   };
283
284   Device(DeviceInfo &info_, Stats &stats_, Profiler &profiler_, bool background)
285       : background(background),
286         vertex_buffer(0),
287         fallback_status(FALLBACK_SHADER_STATUS_NONE),
288         fallback_shader_program(0),
289         info(info_),
290         stats(stats_),
291         profiler(profiler_)
292   {
293   }
294
295   bool background;
296   string error_msg;
297
298   /* used for real time display */
299   unsigned int vertex_buffer;
300   int fallback_status, fallback_shader_program;
301   int image_texture_location, fullscreen_location;
302
303   bool bind_fallback_display_space_shader(const float width, const float height);
304
305   virtual device_ptr mem_alloc_sub_ptr(device_memory & /*mem*/, int /*offset*/, int /*size*/)
306   {
307     /* Only required for devices that implement denoising. */
308     assert(false);
309     return (device_ptr)0;
310   }
311   virtual void mem_free_sub_ptr(device_ptr /*ptr*/){};
312
313  public:
314   virtual ~Device();
315
316   /* info */
317   DeviceInfo info;
318   virtual const string &error_message()
319   {
320     return error_msg;
321   }
322   bool have_error()
323   {
324     return !error_message().empty();
325   }
326   virtual void set_error(const string &error)
327   {
328     if (!have_error()) {
329       error_msg = error;
330     }
331     fprintf(stderr, "%s\n", error.c_str());
332     fflush(stderr);
333   }
334   virtual bool show_samples() const
335   {
336     return false;
337   }
338   virtual BVHLayoutMask get_bvh_layout_mask() const = 0;
339
340   /* statistics */
341   Stats &stats;
342   Profiler &profiler;
343
344   /* memory alignment */
345   virtual int mem_sub_ptr_alignment()
346   {
347     return MIN_ALIGNMENT_CPU_DATA_TYPES;
348   }
349
350   /* constant memory */
351   virtual void const_copy_to(const char *name, void *host, size_t size) = 0;
352
353   /* open shading language, only for CPU device */
354   virtual void *osl_memory()
355   {
356     return NULL;
357   }
358
359   /* load/compile kernels, must be called before adding tasks */
360   virtual bool load_kernels(const DeviceRequestedFeatures & /*requested_features*/)
361   {
362     return true;
363   }
364
365   /* Wait for device to become available to upload data and receive tasks
366    * This method is used by the OpenCL device to load the
367    * optimized kernels or when not (yet) available load the
368    * generic kernels (only during foreground rendering) */
369   virtual bool wait_for_availability(const DeviceRequestedFeatures & /*requested_features*/)
370   {
371     return true;
372   }
373   /* Check if there are 'better' kernels available to be used
374    * We can switch over to these kernels
375    * This method is used to determine if we can switch the preview kernels
376    * to regular kernels */
377   virtual DeviceKernelStatus get_active_kernel_switch_state()
378   {
379     return DEVICE_KERNEL_USING_FEATURE_KERNEL;
380   }
381
382   /* tasks */
383   virtual int get_split_task_count(DeviceTask &task) = 0;
384   virtual void task_add(DeviceTask &task) = 0;
385   virtual void task_wait() = 0;
386   virtual void task_cancel() = 0;
387
388   /* opengl drawing */
389   virtual void draw_pixels(device_memory &mem,
390                            int y,
391                            int w,
392                            int h,
393                            int width,
394                            int height,
395                            int dx,
396                            int dy,
397                            int dw,
398                            int dh,
399                            bool transparent,
400                            const DeviceDrawParams &draw_params);
401
402 #ifdef WITH_NETWORK
403   /* networking */
404   void server_run();
405 #endif
406
407   /* multi device */
408   virtual void map_tile(Device * /*sub_device*/, RenderTile & /*tile*/)
409   {
410   }
411   virtual int device_number(Device * /*sub_device*/)
412   {
413     return 0;
414   }
415   virtual void map_neighbor_tiles(Device * /*sub_device*/, RenderTile * /*tiles*/)
416   {
417   }
418   virtual void unmap_neighbor_tiles(Device * /*sub_device*/, RenderTile * /*tiles*/)
419   {
420   }
421
422   /* static */
423   static Device *create(DeviceInfo &info,
424                         Stats &stats,
425                         Profiler &profiler,
426                         bool background = true);
427
428   static DeviceType type_from_string(const char *name);
429   static string string_from_type(DeviceType type);
430   static vector<DeviceType> available_types();
431   static vector<DeviceInfo> available_devices(uint device_type_mask = DEVICE_MASK_ALL);
432   static string device_capabilities(uint device_type_mask = DEVICE_MASK_ALL);
433   static DeviceInfo get_multi_device(const vector<DeviceInfo> &subdevices,
434                                      int threads,
435                                      bool background);
436
437   /* Tag devices lists for update. */
438   static void tag_update();
439
440   static void free_memory();
441
442  protected:
443   /* Memory allocation, only accessed through device_memory. */
444   friend class MultiDevice;
445   friend class DeviceServer;
446   friend class device_memory;
447
448   virtual void mem_alloc(device_memory &mem) = 0;
449   virtual void mem_copy_to(device_memory &mem) = 0;
450   virtual void mem_copy_from(device_memory &mem, int y, int w, int h, int elem) = 0;
451   virtual void mem_zero(device_memory &mem) = 0;
452   virtual void mem_free(device_memory &mem) = 0;
453
454  private:
455   /* Indicted whether device types and devices lists were initialized. */
456   static bool need_types_update, need_devices_update;
457   static thread_mutex device_mutex;
458   static vector<DeviceInfo> cuda_devices;
459   static vector<DeviceInfo> opencl_devices;
460   static vector<DeviceInfo> cpu_devices;
461   static vector<DeviceInfo> network_devices;
462   static uint devices_initialized_mask;
463 };
464
465 CCL_NAMESPACE_END
466
467 #endif /* __DEVICE_H__ */