示例#1
0
class _PluginConfigurationWidget(BorderWidget):
    on_change = QtCore.Signal()

    def __init__(self, plugin_configuration, parent):
        super(_PluginConfigurationWidget, self).__init__(parent=parent)
        self.plugin_configuration = plugin_configuration

        self.main_layout = QtWidgets.QVBoxLayout(self)
        self.main_layout.setContentsMargins(
            self.main_layout.contentsMargins().left() // 2,
            self.main_layout.contentsMargins().top() // 2,
            self.main_layout.contentsMargins().right() // 2,
            self.main_layout.contentsMargins().bottom() // 2)

        self.plugin_type = plugin_configuration.plugin_type
        if self.plugin_type == RprUsd.kPluginHybrid:
            plugin_qualities = 'Low-High Qualities'
        elif self.plugin_type == RprUsd.kPluginTahoe:
            plugin_qualities = 'Full (Legacy) Quality'
        elif self.plugin_type == RprUsd.kPluginNorthstar:
            plugin_qualities = 'Full Quality'

        self.labels_widget = QtWidgets.QWidget(self)
        self.main_layout.addWidget(self.labels_widget)

        self.labels_widget_layout = QtWidgets.QHBoxLayout(self.labels_widget)
        self.labels_widget_layout.setContentsMargins(0, 0, 0, 0)

        self.plugin_qualities_label = QtWidgets.QLabel(self.labels_widget)
        self.plugin_qualities_label.setText(plugin_qualities)
        self.labels_widget_layout.addWidget(self.plugin_qualities_label)

        self.incomplete_config_label = QtWidgets.QLabel(self.labels_widget)
        self.incomplete_config_label.setStyleSheet('color: rgb(255,204,0)')
        self.incomplete_config_label.setText('Configuration is incomplete: no devices')
        self.labels_widget_layout.addWidget(self.incomplete_config_label)
        self.incomplete_config_label.hide()

        if plugin_configuration.cpu_config.cpu_info.numThreads:
            cpu_widget = _DeviceWidget(parent=self, cpu_config=plugin_configuration.cpu_config)
            cpu_widget.on_change.connect(self.on_device_change)
            self.main_layout.addWidget(cpu_widget)

        for gpu_config in plugin_configuration.gpu_configs:
            gpu_widget = _DeviceWidget(parent=self, gpu_config=gpu_config)
            gpu_widget.on_change.connect(self.on_device_change)
            self.main_layout.addWidget(gpu_widget)

        self.is_complete = True

    def on_device_change(self):
        self.is_complete = self.plugin_configuration.cpu_config.num_active_threads > 0 or \
                           any([gpu_config.is_enabled for gpu_config in self.plugin_configuration.gpu_configs])

        if self.is_complete:
            self.incomplete_config_label.hide()
        else:
            self.incomplete_config_label.show()

        self.on_change.emit()
示例#2
0
class _DeviceWidget(BorderWidget):
    on_change = QtCore.Signal()

    def __init__(self, cpu_config=None, gpu_config=None, parent=None):
        super(_DeviceWidget, self).__init__(parent=parent)

        self.cpu_config = cpu_config
        self.gpu_config = gpu_config

        if gpu_config:
            self.device_name_label = QtWidgets.QLabel(self)
            self.device_name_label.setText('GPU "{}"'.format(gpu_config.gpu_info.name))

            self.main_layout = QtWidgets.QHBoxLayout(self)
            self.main_layout.addWidget(self.device_name_label)

            self.main_layout.addStretch()

            self.is_enabled_check_box = QtWidgets.QCheckBox(self)
            self.is_enabled_check_box.setChecked(gpu_config.is_enabled)
            self.is_enabled_check_box.stateChanged.connect(self.on_gpu_update)
            self.main_layout.addWidget(self.is_enabled_check_box)

        elif cpu_config:
            self.name_container_widget = QtWidgets.QWidget(self)
            self.name_container_layout = QtWidgets.QHBoxLayout(self.name_container_widget)
            self.name_container_layout.setContentsMargins(0, 0, 0, 0)

            self.name_label = QtWidgets.QLabel(self.name_container_widget)
            self.name_label.setText('CPU')
            self.name_container_layout.addWidget(self.name_label)

            self.name_container_layout.addStretch()

            is_cpu_enabled = cpu_config.num_active_threads > 0

            self.is_enabled_check_box = QtWidgets.QCheckBox(self.name_container_widget)
            self.is_enabled_check_box.setChecked(is_cpu_enabled)
            self.is_enabled_check_box.stateChanged.connect(self.on_cpu_enabled_update)
            self.name_container_layout.addWidget(self.is_enabled_check_box)

            self.num_threads_container_widget = QtWidgets.QWidget(self)
            self.num_threads_container_layout = QtWidgets.QHBoxLayout(self.num_threads_container_widget)
            self.num_threads_container_layout.setContentsMargins(0, 0, 0, 0)

            self.num_threads_label = QtWidgets.QLabel(self.num_threads_container_widget)
            self.num_threads_label.setText('Number of Threads')
            self.num_threads_container_layout.addWidget(self.num_threads_label)

            self.num_threads_container_layout.addStretch()

            self.num_threads_spin_box = QtWidgets.QSpinBox(self.num_threads_container_widget)
            self.num_threads_spin_box.setValue(cpu_config.num_active_threads)
            self.num_threads_spin_box.setRange(1, cpu_config.cpu_info.numThreads)
            self.num_threads_spin_box.valueChanged.connect(self.on_cpu_num_threads_update)
            if not is_cpu_enabled:
                self.num_threads_container_widget.hide()
            self.num_threads_container_layout.addWidget(self.num_threads_spin_box)

            self.main_layout = QtWidgets.QVBoxLayout(self)
            self.main_layout.addWidget(self.name_container_widget)
            self.main_layout.addWidget(self.num_threads_container_widget)

        self.main_layout.setContentsMargins(
            self.main_layout.contentsMargins().left() // 2,
            self.main_layout.contentsMargins().top() // 4,
            self.main_layout.contentsMargins().right() // 2,
            self.main_layout.contentsMargins().bottom() // 4)

    def on_gpu_update(self, is_enabled):
        self.gpu_config.is_enabled = bool(is_enabled)
        self.on_change.emit()

    def on_cpu_enabled_update(self, is_enabled):
        if is_enabled:
            self.cpu_config.num_active_threads = self.cpu_config.cpu_info.numThreads
            self.num_threads_spin_box.setValue(self.cpu_config.num_active_threads)
            self.num_threads_container_widget.show()
        else:
            self.cpu_config.num_active_threads = 0
            self.num_threads_container_widget.hide()
        self.on_change.emit()

    def on_cpu_num_threads_update(self, num_threads):
        self.cpu_config.num_active_threads = num_threads
        self.on_change.emit()