Cycles; Make baking a feature-specific option
[blender-staging.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 "device_memory.h"
23 #include "device_task.h"
24
25 #include "util_list.h"
26 #include "util_stats.h"
27 #include "util_string.h"
28 #include "util_thread.h"
29 #include "util_types.h"
30 #include "util_vector.h"
31
32 CCL_NAMESPACE_BEGIN
33
34 class Progress;
35 class RenderTile;
36
37 /* Device Types */
38
39 enum DeviceType {
40         DEVICE_NONE,
41         DEVICE_CPU,
42         DEVICE_OPENCL,
43         DEVICE_CUDA,
44         DEVICE_NETWORK,
45         DEVICE_MULTI
46 };
47
48 class DeviceInfo {
49 public:
50         DeviceType type;
51         string description;
52         string id;
53         int num;
54         bool display_device;
55         bool advanced_shading;
56         bool pack_images;
57         bool extended_images; /* flag for GPU and Multi device */
58         bool use_split_kernel; /* Denotes if the device is going to run cycles using split-kernel */
59         vector<DeviceInfo> multi_devices;
60
61         DeviceInfo()
62         {
63                 type = DEVICE_CPU;
64                 id = "CPU";
65                 num = 0;
66                 display_device = false;
67                 advanced_shading = true;
68                 pack_images = false;
69                 extended_images = false;
70                 use_split_kernel = false;
71         }
72 };
73
74 class DeviceRequestedFeatures {
75 public:
76         /* Use experimental feature set. */
77         bool experimental;
78
79         /* Maximum number of closures in shader trees. */
80         int max_closure;
81
82         /* Selective nodes compilation. */
83
84         /* Identifier of a node group up to which all the nodes needs to be
85          * compiled in. Nodes from higher group indices will be ignores.
86          */
87         int max_nodes_group;
88
89         /* Features bitfield indicating which features from the requested group
90          * will be compiled in. Nodes which corresponds to features which are not
91          * in this bitfield will be ignored even if they're in the requested group.
92          */
93         int nodes_features;
94
95         /* BVH/sampling kernel features. */
96         bool use_hair;
97         bool use_object_motion;
98         bool use_camera_motion;
99
100         /* Denotes whether baking functionality is needed. */
101         bool use_baking;
102
103         DeviceRequestedFeatures()
104         {
105                 /* TODO(sergey): Find more meaningful defaults. */
106                 experimental = false;
107                 max_closure = 0;
108                 max_nodes_group = 0;
109                 nodes_features = 0;
110                 use_hair = false;
111                 use_object_motion = false;
112                 use_camera_motion = false;
113                 use_baking = false;
114         }
115
116         bool modified(const DeviceRequestedFeatures& requested_features)
117         {
118                 return !(experimental == requested_features.experimental &&
119                          max_closure == requested_features.max_closure &&
120                          max_nodes_group == requested_features.max_nodes_group &&
121                          nodes_features == requested_features.nodes_features &&
122                          use_hair == requested_features.use_hair &&
123                          use_object_motion == requested_features.use_object_motion &&
124                          use_camera_motion == requested_features.use_camera_motion &&
125                          use_baking == requested_features.use_baking);
126         }
127 };
128
129 /* Device */
130
131 struct DeviceDrawParams {
132         function<void(void)> bind_display_space_shader_cb;
133         function<void(void)> unbind_display_space_shader_cb;
134 };
135
136 class Device {
137 protected:
138         Device(DeviceInfo& info_, Stats &stats_, bool background) : background(background), vertex_buffer(0), info(info_), stats(stats_) {}
139
140         bool background;
141         string error_msg;
142
143         /* used for real time display */
144         unsigned int vertex_buffer;
145
146 public:
147         virtual ~Device();
148
149         /* info */
150         DeviceInfo info;
151         virtual const string& error_message() { return error_msg; }
152         bool have_error() { return !error_message().empty(); }
153
154         /* statistics */
155         Stats &stats;
156
157         /* regular memory */
158         virtual void mem_alloc(device_memory& mem, MemoryType type) = 0;
159         virtual void mem_copy_to(device_memory& mem) = 0;
160         virtual void mem_copy_from(device_memory& mem,
161                 int y, int w, int h, int elem) = 0;
162         virtual void mem_zero(device_memory& mem) = 0;
163         virtual void mem_free(device_memory& mem) = 0;
164
165         /* constant memory */
166         virtual void const_copy_to(const char *name, void *host, size_t size) = 0;
167
168         /* texture memory */
169         virtual void tex_alloc(const char * /*name*/,
170                                device_memory& /*mem*/,
171                                InterpolationType interpolation = INTERPOLATION_NONE,
172                                bool periodic = false)
173         {
174                 (void)interpolation;  /* Ignored. */
175                 (void)periodic;  /* Ignored. */
176         };
177         virtual void tex_free(device_memory& /*mem*/) {};
178
179         /* pixel memory */
180         virtual void pixels_alloc(device_memory& mem);
181         virtual void pixels_copy_from(device_memory& mem, int y, int w, int h);
182         virtual void pixels_free(device_memory& mem);
183
184         /* open shading language, only for CPU device */
185         virtual void *osl_memory() { return NULL; }
186
187         /* load/compile kernels, must be called before adding tasks */ 
188         virtual bool load_kernels(
189                 const DeviceRequestedFeatures& /*requested_features*/)
190         { return true; }
191
192         /* tasks */
193         virtual int get_split_task_count(DeviceTask& task) = 0;
194         virtual void task_add(DeviceTask& task) = 0;
195         virtual void task_wait() = 0;
196         virtual void task_cancel() = 0;
197         
198         /* opengl drawing */
199         virtual void draw_pixels(device_memory& mem, int y, int w, int h,
200                 int dx, int dy, int width, int height, bool transparent,
201                 const DeviceDrawParams &draw_params);
202
203 #ifdef WITH_NETWORK
204         /* networking */
205         void server_run();
206 #endif
207
208         /* multi device */
209         virtual void map_tile(Device * /*sub_device*/, RenderTile& /*tile*/) {}
210         virtual int device_number(Device * /*sub_device*/) { return 0; }
211
212         /* static */
213         static Device *create(DeviceInfo& info, Stats &stats, bool background = true);
214
215         static DeviceType type_from_string(const char *name);
216         static string string_from_type(DeviceType type);
217         static vector<DeviceType>& available_types();
218         static vector<DeviceInfo>& available_devices();
219         static string device_capabilities();
220 };
221
222 CCL_NAMESPACE_END
223
224 #endif /* __DEVICE_H__ */
225