b17abac2a1bf6434d684d36bf47a65f9abc4f339
[blender-staging.git] / intern / cycles / device / device.h
1 /*
2  * Copyright 2011, Blender Foundation.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  */
18
19 #ifndef __DEVICE_H__
20 #define __DEVICE_H__
21
22 #include <stdlib.h>
23
24 #include "device_memory.h"
25
26 #include "util_list.h"
27 #include "util_string.h"
28 #include "util_task.h"
29 #include "util_thread.h"
30 #include "util_types.h"
31 #include "util_vector.h"
32
33 CCL_NAMESPACE_BEGIN
34
35 class Progress;
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         vector<DeviceInfo> multi_devices;
58
59         DeviceInfo()
60         {
61                 type = DEVICE_CPU;
62                 id = "CPU";
63                 num = 0;
64                 display_device = false;
65                 advanced_shading = true;
66                 pack_images = false;
67         }
68 };
69
70 /* Device Task */
71
72 class DeviceTask : public Task {
73 public:
74         typedef enum { PATH_TRACE, TONEMAP, SHADER } Type;
75         Type type;
76
77         int x, y, w, h;
78         device_ptr rng_state;
79         device_ptr rgba;
80         device_ptr buffer;
81         int sample;
82         int resolution;
83         int offset, stride;
84
85         device_ptr shader_input;
86         device_ptr shader_output;
87         int shader_eval_type;
88         int shader_x, shader_w;
89
90         DeviceTask(Type type = PATH_TRACE);
91
92         void split(list<DeviceTask>& tasks, int num);
93         void split_max_size(list<DeviceTask>& tasks, int max_size);
94 };
95
96 /* Device */
97
98 class Device {
99 protected:
100         Device() {}
101
102         bool background;
103         string error_msg;
104
105 public:
106         virtual ~Device() {}
107
108         /* info */
109         DeviceInfo info;
110         virtual const string& error_message() { return error_msg; }
111
112         /* regular memory */
113         virtual void mem_alloc(device_memory& mem, MemoryType type) = 0;
114         virtual void mem_copy_to(device_memory& mem) = 0;
115         virtual void mem_copy_from(device_memory& mem,
116                 int y, int w, int h, int elem) = 0;
117         virtual void mem_zero(device_memory& mem) = 0;
118         virtual void mem_free(device_memory& mem) = 0;
119
120         /* constant memory */
121         virtual void const_copy_to(const char *name, void *host, size_t size) = 0;
122
123         /* texture memory */
124         virtual void tex_alloc(const char *name, device_memory& mem,
125                 bool interpolation = false, bool periodic = false) {};
126         virtual void tex_free(device_memory& mem) {};
127
128         /* pixel memory */
129         virtual void pixels_alloc(device_memory& mem);
130         virtual void pixels_copy_from(device_memory& mem, int y, int w, int h);
131         virtual void pixels_free(device_memory& mem);
132
133         /* open shading language, only for CPU device */
134         virtual void *osl_memory() { return NULL; }
135
136         /* load/compile kernels, must be called before adding tasks */ 
137         virtual bool load_kernels(bool experimental) { return true; }
138
139         /* tasks */
140         virtual void task_add(DeviceTask& task) = 0;
141         virtual void task_wait() = 0;
142         virtual void task_cancel() = 0;
143         
144         /* opengl drawing */
145         virtual void draw_pixels(device_memory& mem, int y, int w, int h,
146                 int dy, int width, int height, bool transparent);
147
148 #ifdef WITH_NETWORK
149         /* networking */
150         void server_run();
151 #endif
152
153         /* static */
154         static Device *create(DeviceInfo& info, bool background = true, int threads = 0);
155
156         static DeviceType type_from_string(const char *name);
157         static string string_from_type(DeviceType type);
158         static vector<DeviceType>& available_types();
159         static vector<DeviceInfo>& available_devices();
160 };
161
162 CCL_NAMESPACE_END
163
164 #endif /* __DEVICE_H__ */
165