Fix T73859: Support executing sculpt.set_pivot_position without invoke
[blender.git] / intern / cycles / device / device.cpp
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 #include <stdlib.h>
18 #include <string.h>
19
20 #include "device/device.h"
21 #include "device/device_intern.h"
22
23 #include "util/util_foreach.h"
24 #include "util/util_half.h"
25 #include "util/util_logging.h"
26 #include "util/util_math.h"
27 #include "util/util_opengl.h"
28 #include "util/util_time.h"
29 #include "util/util_system.h"
30 #include "util/util_types.h"
31 #include "util/util_vector.h"
32 #include "util/util_string.h"
33
34 CCL_NAMESPACE_BEGIN
35
36 bool Device::need_types_update = true;
37 bool Device::need_devices_update = true;
38 thread_mutex Device::device_mutex;
39 vector<DeviceInfo> Device::opencl_devices;
40 vector<DeviceInfo> Device::cuda_devices;
41 vector<DeviceInfo> Device::optix_devices;
42 vector<DeviceInfo> Device::cpu_devices;
43 vector<DeviceInfo> Device::network_devices;
44 uint Device::devices_initialized_mask = 0;
45
46 /* Device Requested Features */
47
48 std::ostream &operator<<(std::ostream &os, const DeviceRequestedFeatures &requested_features)
49 {
50   os << "Experimental features: " << (requested_features.experimental ? "On" : "Off") << std::endl;
51   os << "Max nodes group: " << requested_features.max_nodes_group << std::endl;
52   /* TODO(sergey): Decode bitflag into list of names. */
53   os << "Nodes features: " << requested_features.nodes_features << std::endl;
54   os << "Use Hair: " << string_from_bool(requested_features.use_hair) << std::endl;
55   os << "Use Object Motion: " << string_from_bool(requested_features.use_object_motion)
56      << std::endl;
57   os << "Use Camera Motion: " << string_from_bool(requested_features.use_camera_motion)
58      << std::endl;
59   os << "Use Baking: " << string_from_bool(requested_features.use_baking) << std::endl;
60   os << "Use Subsurface: " << string_from_bool(requested_features.use_subsurface) << std::endl;
61   os << "Use Volume: " << string_from_bool(requested_features.use_volume) << std::endl;
62   os << "Use Branched Integrator: " << string_from_bool(requested_features.use_integrator_branched)
63      << std::endl;
64   os << "Use Patch Evaluation: " << string_from_bool(requested_features.use_patch_evaluation)
65      << std::endl;
66   os << "Use Transparent Shadows: " << string_from_bool(requested_features.use_transparent)
67      << std::endl;
68   os << "Use Principled BSDF: " << string_from_bool(requested_features.use_principled)
69      << std::endl;
70   os << "Use Denoising: " << string_from_bool(requested_features.use_denoising) << std::endl;
71   os << "Use Displacement: " << string_from_bool(requested_features.use_true_displacement)
72      << std::endl;
73   os << "Use Background Light: " << string_from_bool(requested_features.use_background_light)
74      << std::endl;
75   return os;
76 }
77
78 /* Device */
79
80 Device::~Device()
81 {
82   if (!background) {
83     if (vertex_buffer != 0) {
84       glDeleteBuffers(1, &vertex_buffer);
85     }
86     if (fallback_shader_program != 0) {
87       glDeleteProgram(fallback_shader_program);
88     }
89   }
90 }
91
92 /* TODO move shaders to standalone .glsl file. */
93 const char *FALLBACK_VERTEX_SHADER =
94     "#version 330\n"
95     "uniform vec2 fullscreen;\n"
96     "in vec2 texCoord;\n"
97     "in vec2 pos;\n"
98     "out vec2 texCoord_interp;\n"
99     "\n"
100     "vec2 normalize_coordinates()\n"
101     "{\n"
102     "   return (vec2(2.0) * (pos / fullscreen)) - vec2(1.0);\n"
103     "}\n"
104     "\n"
105     "void main()\n"
106     "{\n"
107     "   gl_Position = vec4(normalize_coordinates(), 0.0, 1.0);\n"
108     "   texCoord_interp = texCoord;\n"
109     "}\n\0";
110
111 const char *FALLBACK_FRAGMENT_SHADER =
112     "#version 330\n"
113     "uniform sampler2D image_texture;\n"
114     "in vec2 texCoord_interp;\n"
115     "out vec4 fragColor;\n"
116     "\n"
117     "void main()\n"
118     "{\n"
119     "   fragColor = texture(image_texture, texCoord_interp);\n"
120     "}\n\0";
121
122 static void shader_print_errors(const char *task, const char *log, const char *code)
123 {
124   LOG(ERROR) << "Shader: " << task << " error:";
125   LOG(ERROR) << "===== shader string ====";
126
127   stringstream stream(code);
128   string partial;
129
130   int line = 1;
131   while (getline(stream, partial, '\n')) {
132     if (line < 10) {
133       LOG(ERROR) << " " << line << " " << partial;
134     }
135     else {
136       LOG(ERROR) << line << " " << partial;
137     }
138     line++;
139   }
140   LOG(ERROR) << log;
141 }
142
143 static int bind_fallback_shader(void)
144 {
145   GLint status;
146   GLchar log[5000];
147   GLsizei length = 0;
148   GLuint program = 0;
149
150   struct Shader {
151     const char *source;
152     GLenum type;
153   } shaders[2] = {{FALLBACK_VERTEX_SHADER, GL_VERTEX_SHADER},
154                   {FALLBACK_FRAGMENT_SHADER, GL_FRAGMENT_SHADER}};
155
156   program = glCreateProgram();
157
158   for (int i = 0; i < 2; i++) {
159     GLuint shader = glCreateShader(shaders[i].type);
160
161     string source_str = shaders[i].source;
162     const char *c_str = source_str.c_str();
163
164     glShaderSource(shader, 1, &c_str, NULL);
165     glCompileShader(shader);
166
167     glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
168
169     if (!status) {
170       glGetShaderInfoLog(shader, sizeof(log), &length, log);
171       shader_print_errors("compile", log, c_str);
172       return 0;
173     }
174
175     glAttachShader(program, shader);
176   }
177
178   /* Link output. */
179   glBindFragDataLocation(program, 0, "fragColor");
180
181   /* Link and error check. */
182   glLinkProgram(program);
183
184   glGetProgramiv(program, GL_LINK_STATUS, &status);
185   if (!status) {
186     glGetShaderInfoLog(program, sizeof(log), &length, log);
187     shader_print_errors("linking", log, FALLBACK_VERTEX_SHADER);
188     shader_print_errors("linking", log, FALLBACK_FRAGMENT_SHADER);
189     return 0;
190   }
191
192   return program;
193 }
194
195 bool Device::bind_fallback_display_space_shader(const float width, const float height)
196 {
197   if (fallback_status == FALLBACK_SHADER_STATUS_ERROR) {
198     return false;
199   }
200
201   if (fallback_status == FALLBACK_SHADER_STATUS_NONE) {
202     fallback_shader_program = bind_fallback_shader();
203     fallback_status = FALLBACK_SHADER_STATUS_ERROR;
204
205     if (fallback_shader_program == 0) {
206       return false;
207     }
208
209     glUseProgram(fallback_shader_program);
210     image_texture_location = glGetUniformLocation(fallback_shader_program, "image_texture");
211     if (image_texture_location < 0) {
212       LOG(ERROR) << "Shader doesn't containt the 'image_texture' uniform.";
213       return false;
214     }
215
216     fullscreen_location = glGetUniformLocation(fallback_shader_program, "fullscreen");
217     if (fullscreen_location < 0) {
218       LOG(ERROR) << "Shader doesn't containt the 'fullscreen' uniform.";
219       return false;
220     }
221
222     fallback_status = FALLBACK_SHADER_STATUS_SUCCESS;
223   }
224
225   /* Run this every time. */
226   glUseProgram(fallback_shader_program);
227   glUniform1i(image_texture_location, 0);
228   glUniform2f(fullscreen_location, width, height);
229   return true;
230 }
231
232 void Device::draw_pixels(device_memory &rgba,
233                          int y,
234                          int w,
235                          int h,
236                          int width,
237                          int height,
238                          int dx,
239                          int dy,
240                          int dw,
241                          int dh,
242                          bool transparent,
243                          const DeviceDrawParams &draw_params)
244 {
245   const bool use_fallback_shader = (draw_params.bind_display_space_shader_cb == NULL);
246
247   assert(rgba.type == MEM_PIXELS);
248   mem_copy_from(rgba, y, w, h, rgba.memory_elements_size(1));
249
250   GLuint texid;
251   glActiveTexture(GL_TEXTURE0);
252   glGenTextures(1, &texid);
253   glBindTexture(GL_TEXTURE_2D, texid);
254
255   if (rgba.data_type == TYPE_HALF) {
256     GLhalf *data_pointer = (GLhalf *)rgba.host_pointer;
257     data_pointer += 4 * y * w;
258     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, w, h, 0, GL_RGBA, GL_HALF_FLOAT, data_pointer);
259   }
260   else {
261     uint8_t *data_pointer = (uint8_t *)rgba.host_pointer;
262     data_pointer += 4 * y * w;
263     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data_pointer);
264   }
265
266   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
267   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
268
269   if (transparent) {
270     glEnable(GL_BLEND);
271     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
272   }
273
274   GLint shader_program;
275   if (use_fallback_shader) {
276     if (!bind_fallback_display_space_shader(dw, dh)) {
277       return;
278     }
279     shader_program = fallback_shader_program;
280   }
281   else {
282     draw_params.bind_display_space_shader_cb();
283     glGetIntegerv(GL_CURRENT_PROGRAM, &shader_program);
284   }
285
286   if (!vertex_buffer) {
287     glGenBuffers(1, &vertex_buffer);
288   }
289
290   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
291   /* invalidate old contents - avoids stalling if buffer is still waiting in queue to be rendered
292    */
293   glBufferData(GL_ARRAY_BUFFER, 16 * sizeof(float), NULL, GL_STREAM_DRAW);
294
295   float *vpointer = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
296
297   if (vpointer) {
298     /* texture coordinate - vertex pair */
299     vpointer[0] = 0.0f;
300     vpointer[1] = 0.0f;
301     vpointer[2] = dx;
302     vpointer[3] = dy;
303
304     vpointer[4] = 1.0f;
305     vpointer[5] = 0.0f;
306     vpointer[6] = (float)width + dx;
307     vpointer[7] = dy;
308
309     vpointer[8] = 1.0f;
310     vpointer[9] = 1.0f;
311     vpointer[10] = (float)width + dx;
312     vpointer[11] = (float)height + dy;
313
314     vpointer[12] = 0.0f;
315     vpointer[13] = 1.0f;
316     vpointer[14] = dx;
317     vpointer[15] = (float)height + dy;
318
319     if (vertex_buffer) {
320       glUnmapBuffer(GL_ARRAY_BUFFER);
321     }
322   }
323
324   GLuint vertex_array_object;
325   GLuint position_attribute, texcoord_attribute;
326
327   glGenVertexArrays(1, &vertex_array_object);
328   glBindVertexArray(vertex_array_object);
329
330   texcoord_attribute = glGetAttribLocation(shader_program, "texCoord");
331   position_attribute = glGetAttribLocation(shader_program, "pos");
332
333   glEnableVertexAttribArray(texcoord_attribute);
334   glEnableVertexAttribArray(position_attribute);
335
336   glVertexAttribPointer(
337       texcoord_attribute, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (const GLvoid *)0);
338   glVertexAttribPointer(position_attribute,
339                         2,
340                         GL_FLOAT,
341                         GL_FALSE,
342                         4 * sizeof(float),
343                         (const GLvoid *)(sizeof(float) * 2));
344
345   glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
346
347   if (vertex_buffer) {
348     glBindBuffer(GL_ARRAY_BUFFER, 0);
349   }
350
351   if (use_fallback_shader) {
352     glUseProgram(0);
353   }
354   else {
355     draw_params.unbind_display_space_shader_cb();
356   }
357
358   glDeleteVertexArrays(1, &vertex_array_object);
359   glBindTexture(GL_TEXTURE_2D, 0);
360   glDeleteTextures(1, &texid);
361
362   if (transparent) {
363     glDisable(GL_BLEND);
364   }
365 }
366
367 Device *Device::create(DeviceInfo &info, Stats &stats, Profiler &profiler, bool background)
368 {
369 #ifdef WITH_MULTI
370   if (!info.multi_devices.empty()) {
371     /* Always create a multi device when info contains multiple devices.
372      * This is done so that the type can still be e.g. DEVICE_CPU to indicate
373      * that it is a homogeneous collection of devices, which simplifies checks. */
374     return device_multi_create(info, stats, profiler, background);
375   }
376 #endif
377
378   Device *device;
379
380   switch (info.type) {
381     case DEVICE_CPU:
382       device = device_cpu_create(info, stats, profiler, background);
383       break;
384 #ifdef WITH_CUDA
385     case DEVICE_CUDA:
386       if (device_cuda_init())
387         device = device_cuda_create(info, stats, profiler, background);
388       else
389         device = NULL;
390       break;
391 #endif
392 #ifdef WITH_OPTIX
393     case DEVICE_OPTIX:
394       if (device_optix_init())
395         device = device_optix_create(info, stats, profiler, background);
396       else
397         device = NULL;
398       break;
399 #endif
400 #ifdef WITH_NETWORK
401     case DEVICE_NETWORK:
402       device = device_network_create(info, stats, profiler, "127.0.0.1");
403       break;
404 #endif
405 #ifdef WITH_OPENCL
406     case DEVICE_OPENCL:
407       if (device_opencl_init())
408         device = device_opencl_create(info, stats, profiler, background);
409       else
410         device = NULL;
411       break;
412 #endif
413     default:
414       return NULL;
415   }
416
417   return device;
418 }
419
420 DeviceType Device::type_from_string(const char *name)
421 {
422   if (strcmp(name, "CPU") == 0)
423     return DEVICE_CPU;
424   else if (strcmp(name, "CUDA") == 0)
425     return DEVICE_CUDA;
426   else if (strcmp(name, "OPTIX") == 0)
427     return DEVICE_OPTIX;
428   else if (strcmp(name, "OPENCL") == 0)
429     return DEVICE_OPENCL;
430   else if (strcmp(name, "NETWORK") == 0)
431     return DEVICE_NETWORK;
432   else if (strcmp(name, "MULTI") == 0)
433     return DEVICE_MULTI;
434
435   return DEVICE_NONE;
436 }
437
438 string Device::string_from_type(DeviceType type)
439 {
440   if (type == DEVICE_CPU)
441     return "CPU";
442   else if (type == DEVICE_CUDA)
443     return "CUDA";
444   else if (type == DEVICE_OPTIX)
445     return "OPTIX";
446   else if (type == DEVICE_OPENCL)
447     return "OPENCL";
448   else if (type == DEVICE_NETWORK)
449     return "NETWORK";
450   else if (type == DEVICE_MULTI)
451     return "MULTI";
452
453   return "";
454 }
455
456 vector<DeviceType> Device::available_types()
457 {
458   vector<DeviceType> types;
459   types.push_back(DEVICE_CPU);
460 #ifdef WITH_CUDA
461   types.push_back(DEVICE_CUDA);
462 #endif
463 #ifdef WITH_OPTIX
464   types.push_back(DEVICE_OPTIX);
465 #endif
466 #ifdef WITH_OPENCL
467   types.push_back(DEVICE_OPENCL);
468 #endif
469 #ifdef WITH_NETWORK
470   types.push_back(DEVICE_NETWORK);
471 #endif
472   return types;
473 }
474
475 vector<DeviceInfo> Device::available_devices(uint mask)
476 {
477   /* Lazy initialize devices. On some platforms OpenCL or CUDA drivers can
478    * be broken and cause crashes when only trying to get device info, so
479    * we don't want to do any initialization until the user chooses to. */
480   thread_scoped_lock lock(device_mutex);
481   vector<DeviceInfo> devices;
482
483 #ifdef WITH_OPENCL
484   if (mask & DEVICE_MASK_OPENCL) {
485     if (!(devices_initialized_mask & DEVICE_MASK_OPENCL)) {
486       if (device_opencl_init()) {
487         device_opencl_info(opencl_devices);
488       }
489       devices_initialized_mask |= DEVICE_MASK_OPENCL;
490     }
491     foreach (DeviceInfo &info, opencl_devices) {
492       devices.push_back(info);
493     }
494   }
495 #endif
496
497 #ifdef WITH_CUDA
498   if (mask & DEVICE_MASK_CUDA) {
499     if (!(devices_initialized_mask & DEVICE_MASK_CUDA)) {
500       if (device_cuda_init()) {
501         device_cuda_info(cuda_devices);
502       }
503       devices_initialized_mask |= DEVICE_MASK_CUDA;
504     }
505     foreach (DeviceInfo &info, cuda_devices) {
506       devices.push_back(info);
507     }
508   }
509 #endif
510
511 #ifdef WITH_OPTIX
512   if (mask & DEVICE_MASK_OPTIX) {
513     if (!(devices_initialized_mask & DEVICE_MASK_OPTIX)) {
514       if (device_optix_init()) {
515         device_optix_info(optix_devices);
516       }
517       devices_initialized_mask |= DEVICE_MASK_OPTIX;
518     }
519     foreach (DeviceInfo &info, optix_devices) {
520       devices.push_back(info);
521     }
522   }
523 #endif
524
525   if (mask & DEVICE_MASK_CPU) {
526     if (!(devices_initialized_mask & DEVICE_MASK_CPU)) {
527       device_cpu_info(cpu_devices);
528       devices_initialized_mask |= DEVICE_MASK_CPU;
529     }
530     foreach (DeviceInfo &info, cpu_devices) {
531       devices.push_back(info);
532     }
533   }
534
535 #ifdef WITH_NETWORK
536   if (mask & DEVICE_MASK_NETWORK) {
537     if (!(devices_initialized_mask & DEVICE_MASK_NETWORK)) {
538       device_network_info(network_devices);
539       devices_initialized_mask |= DEVICE_MASK_NETWORK;
540     }
541     foreach (DeviceInfo &info, network_devices) {
542       devices.push_back(info);
543     }
544   }
545 #endif
546
547   return devices;
548 }
549
550 string Device::device_capabilities(uint mask)
551 {
552   thread_scoped_lock lock(device_mutex);
553   string capabilities = "";
554
555   if (mask & DEVICE_MASK_CPU) {
556     capabilities += "\nCPU device capabilities: ";
557     capabilities += device_cpu_capabilities() + "\n";
558   }
559
560 #ifdef WITH_OPENCL
561   if (mask & DEVICE_MASK_OPENCL) {
562     if (device_opencl_init()) {
563       capabilities += "\nOpenCL device capabilities:\n";
564       capabilities += device_opencl_capabilities();
565     }
566   }
567 #endif
568
569 #ifdef WITH_CUDA
570   if (mask & DEVICE_MASK_CUDA) {
571     if (device_cuda_init()) {
572       capabilities += "\nCUDA device capabilities:\n";
573       capabilities += device_cuda_capabilities();
574     }
575   }
576 #endif
577
578   return capabilities;
579 }
580
581 DeviceInfo Device::get_multi_device(const vector<DeviceInfo> &subdevices,
582                                     int threads,
583                                     bool background)
584 {
585   assert(subdevices.size() > 0);
586
587   if (subdevices.size() == 1) {
588     /* No multi device needed. */
589     return subdevices.front();
590   }
591
592   DeviceInfo info;
593   info.type = subdevices.front().type;
594   info.id = "MULTI";
595   info.description = "Multi Device";
596   info.num = 0;
597
598   info.has_half_images = true;
599   info.has_volume_decoupled = true;
600   info.has_osl = true;
601   info.has_profiling = true;
602
603   foreach (const DeviceInfo &device, subdevices) {
604     /* Ensure CPU device does not slow down GPU. */
605     if (device.type == DEVICE_CPU && subdevices.size() > 1) {
606       if (background) {
607         int orig_cpu_threads = (threads) ? threads : system_cpu_thread_count();
608         int cpu_threads = max(orig_cpu_threads - (subdevices.size() - 1), 0);
609
610         VLOG(1) << "CPU render threads reduced from " << orig_cpu_threads << " to " << cpu_threads
611                 << ", to dedicate to GPU.";
612
613         if (cpu_threads >= 1) {
614           DeviceInfo cpu_device = device;
615           cpu_device.cpu_threads = cpu_threads;
616           info.multi_devices.push_back(cpu_device);
617         }
618         else {
619           continue;
620         }
621       }
622       else {
623         VLOG(1) << "CPU render threads disabled for interactive render.";
624         continue;
625       }
626     }
627     else {
628       info.multi_devices.push_back(device);
629     }
630
631     /* Create unique ID for this combination of devices. */
632     info.id += device.id;
633
634     /* Set device type to MULTI if subdevices are not of a common type. */
635     if (device.type != info.type) {
636       info.type = DEVICE_MULTI;
637     }
638
639     /* Accumulate device info. */
640     info.has_half_images &= device.has_half_images;
641     info.has_volume_decoupled &= device.has_volume_decoupled;
642     info.has_osl &= device.has_osl;
643     info.has_profiling &= device.has_profiling;
644   }
645
646   return info;
647 }
648
649 void Device::tag_update()
650 {
651   free_memory();
652 }
653
654 void Device::free_memory()
655 {
656   devices_initialized_mask = 0;
657   cuda_devices.free_memory();
658   optix_devices.free_memory();
659   opencl_devices.free_memory();
660   cpu_devices.free_memory();
661   network_devices.free_memory();
662 }
663
664 CCL_NAMESPACE_END