Cycles: refactor Blender device settings handling into own file.
authorBrecht Van Lommel <brechtvanlommel@gmail.com>
Wed, 6 Feb 2019 15:15:45 +0000 (16:15 +0100)
committerBrecht Van Lommel <brechtvanlommel@gmail.com>
Mon, 11 Feb 2019 11:53:24 +0000 (12:53 +0100)
intern/cycles/blender/CMakeLists.txt
intern/cycles/blender/blender_device.cpp [new file with mode: 0644]
intern/cycles/blender/blender_device.h [new file with mode: 0644]
intern/cycles/blender/blender_sync.cpp

index 9a26ce8..769bc78 100644 (file)
@@ -17,6 +17,7 @@ set(INC_SYS
 
 set(SRC
        blender_camera.cpp
+       blender_device.cpp
        blender_mesh.cpp
        blender_object.cpp
        blender_object_cull.cpp
diff --git a/intern/cycles/blender/blender_device.cpp b/intern/cycles/blender/blender_device.cpp
new file mode 100644 (file)
index 0000000..d689508
--- /dev/null
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2011-2013 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "blender/blender_device.h"
+#include "blender/blender_util.h"
+
+CCL_NAMESPACE_BEGIN
+
+int blender_device_threads(BL::Scene& b_scene)
+{
+       BL::RenderSettings b_r = b_scene.render();
+
+       if(b_r.threads_mode() == BL::RenderSettings::threads_mode_FIXED)
+               return b_r.threads();
+       else
+               return 0;
+}
+
+DeviceInfo blender_device_info(BL::UserPreferences& b_userpref, BL::Scene& b_scene, bool background)
+{
+       PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
+
+       /* Default to CPU device. */
+       DeviceInfo device = Device::available_devices(DEVICE_MASK_CPU).front();
+
+       if(get_enum(cscene, "device") == 2) {
+               /* Find network device. */
+               vector<DeviceInfo> devices = Device::available_devices(DEVICE_MASK_NETWORK);
+               if(!devices.empty()) {
+                       device = devices.front();
+               }
+       }
+       else if(get_enum(cscene, "device") == 1) {
+               /* Find cycles preferences. */
+               PointerRNA cpreferences;
+
+               BL::UserPreferences::addons_iterator b_addon_iter;
+               for(b_userpref.addons.begin(b_addon_iter); b_addon_iter != b_userpref.addons.end(); ++b_addon_iter) {
+                       if(b_addon_iter->module() == "cycles") {
+                               cpreferences = b_addon_iter->preferences().ptr;
+                               break;
+                       }
+               }
+
+               /* Test if we are using GPU devices. */
+               enum ComputeDevice {
+                       COMPUTE_DEVICE_CPU = 0,
+                       COMPUTE_DEVICE_CUDA = 1,
+                       COMPUTE_DEVICE_OPENCL = 2,
+                       COMPUTE_DEVICE_NUM = 3,
+               };
+
+               ComputeDevice compute_device = (ComputeDevice)get_enum(cpreferences,
+                                                                      "compute_device_type",
+                                                                      COMPUTE_DEVICE_NUM,
+                                                                      COMPUTE_DEVICE_CPU);
+
+               if(compute_device != COMPUTE_DEVICE_CPU) {
+                       /* Query GPU devices with matching types. */
+                       uint mask = DEVICE_MASK_CPU;
+                       if(compute_device == COMPUTE_DEVICE_CUDA) {
+                               mask |= DEVICE_MASK_CUDA;
+                       }
+                       else if(compute_device == COMPUTE_DEVICE_OPENCL) {
+                               mask |= DEVICE_MASK_OPENCL;
+                       }
+                       vector<DeviceInfo> devices = Device::available_devices(mask);
+
+                       /* Match device preferences and available devices. */
+                       vector<DeviceInfo> used_devices;
+                       RNA_BEGIN(&cpreferences, device, "devices") {
+                               if(get_boolean(device, "use")) {
+                                       string id = get_string(device, "id");
+                                       foreach(DeviceInfo& info, devices) {
+                                               if(info.id == id) {
+                                                       used_devices.push_back(info);
+                                                       break;
+                                               }
+                                       }
+                               }
+                       } RNA_END;
+
+                       if(!used_devices.empty()) {
+                               int threads = blender_device_threads(b_scene);
+                               device = Device::get_multi_device(used_devices,
+                                                                 threads,
+                                                                 background);
+                       }
+                       /* Else keep using the CPU device that was set before. */
+               }
+       }
+
+       return device;
+}
+
+CCL_NAMESPACE_END
diff --git a/intern/cycles/blender/blender_device.h b/intern/cycles/blender/blender_device.h
new file mode 100644 (file)
index 0000000..315cdac
--- /dev/null
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2011-2013 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __BLENDER_DEVICE_H__
+#define __BLENDER_DEVICE_H__
+
+#include "MEM_guardedalloc.h"
+#include "RNA_types.h"
+#include "RNA_access.h"
+#include "RNA_blender_cpp.h"
+
+#include "device/device.h"
+
+CCL_NAMESPACE_BEGIN
+
+/* Get number of threads to use for rendering. */
+int blender_device_threads(BL::Scene& b_scene);
+
+/* Convert Blender settings to device specification. */
+DeviceInfo blender_device_info(BL::UserPreferences& b_userpref, BL::Scene& b_scene, bool background);
+
+CCL_NAMESPACE_END
+
+#endif  /* __BLENDER_DEVICE_H__ */
index a6050b6..05979fa 100644 (file)
@@ -29,6 +29,7 @@
 
 #include "device/device.h"
 
+#include "blender/blender_device.h"
 #include "blender/blender_sync.h"
 #include "blender/blender_session.h"
 #include "blender/blender_util.h"
@@ -751,84 +752,12 @@ SessionParams BlenderSync::get_session_params(BL::RenderEngine& b_engine,
        /* feature set */
        params.experimental = (get_enum(cscene, "feature_set") != 0);
 
-       /* threads */
-       BL::RenderSettings b_r = b_scene.render();
-       if(b_r.threads_mode() == BL::RenderSettings::threads_mode_FIXED)
-               params.threads = b_r.threads();
-       else
-               params.threads = 0;
-
        /* Background */
        params.background = background;
 
-       /* Default to CPU device. */
-       params.device = Device::available_devices(DEVICE_MASK_CPU).front();
-
-       if(get_enum(cscene, "device") == 2) {
-               /* Find network device. */
-               vector<DeviceInfo> devices = Device::available_devices(DEVICE_MASK_NETWORK);
-               if(!devices.empty()) {
-                       params.device = devices.front();
-               }
-       }
-       else if(get_enum(cscene, "device") == 1) {
-               /* Find cycles preferences. */
-               PointerRNA b_preferences;
-
-               BL::UserPreferences::addons_iterator b_addon_iter;
-               for(b_userpref.addons.begin(b_addon_iter); b_addon_iter != b_userpref.addons.end(); ++b_addon_iter) {
-                       if(b_addon_iter->module() == "cycles") {
-                               b_preferences = b_addon_iter->preferences().ptr;
-                               break;
-                       }
-               }
-
-               /* Test if we are using GPU devices. */
-               enum ComputeDevice {
-                       COMPUTE_DEVICE_CPU = 0,
-                       COMPUTE_DEVICE_CUDA = 1,
-                       COMPUTE_DEVICE_OPENCL = 2,
-                       COMPUTE_DEVICE_NUM = 3,
-               };
-
-               ComputeDevice compute_device = (ComputeDevice)get_enum(b_preferences,
-                                                                      "compute_device_type",
-                                                                      COMPUTE_DEVICE_NUM,
-                                                                      COMPUTE_DEVICE_CPU);
-
-               if(compute_device != COMPUTE_DEVICE_CPU) {
-                       /* Query GPU devices with matching types. */
-                       uint mask = DEVICE_MASK_CPU;
-                       if(compute_device == COMPUTE_DEVICE_CUDA) {
-                               mask |= DEVICE_MASK_CUDA;
-                       }
-                       else if(compute_device == COMPUTE_DEVICE_OPENCL) {
-                               mask |= DEVICE_MASK_OPENCL;
-                       }
-                       vector<DeviceInfo> devices = Device::available_devices(mask);
-
-                       /* Match device preferences and available devices. */
-                       vector<DeviceInfo> used_devices;
-                       RNA_BEGIN(&b_preferences, device, "devices") {
-                               if(get_boolean(device, "use")) {
-                                       string id = get_string(device, "id");
-                                       foreach(DeviceInfo& info, devices) {
-                                               if(info.id == id) {
-                                                       used_devices.push_back(info);
-                                                       break;
-                                               }
-                                       }
-                               }
-                       } RNA_END;
-
-                       if(!used_devices.empty()) {
-                               params.device = Device::get_multi_device(used_devices,
-                                                                        params.threads,
-                                                                        params.background);
-                       }
-                       /* Else keep using the CPU device that was set before. */
-               }
-       }
+       /* Device */
+       params.threads = blender_device_threads(b_scene);
+       params.device = blender_device_info(b_userpref, b_scene, params.background);
 
        /* samples */
        int samples = get_int(cscene, "samples");
@@ -900,6 +829,7 @@ SessionParams BlenderSync::get_session_params(BL::RenderEngine& b_engine,
        params.text_timeout = (double)get_float(cscene, "debug_text_timeout");
 
        /* progressive refine */
+       BL::RenderSettings b_r = b_scene.render();
        params.progressive_refine = get_boolean(cscene, "use_progressive_refine") &&
                                    !b_r.use_save_buffers();