Mirrors/overte-lubosz
3
0
Fork 0
mirror of https://github.com/lubosz/overte.git synced 2025-04-24 12:43:19 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #15670 from samcake/nut

Browse source 
BUGZ-467 and BUGZ-488 : Fixing buggy performance preset setup behavior
This commit is contained in:
Sam Gateau 2019-06-04 12:03:09 -07:00 committed by GitHub
commit 2fbb28835c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
18 changed files with 289 additions and 164 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
interface/src/Application.cpp
View file

@ -5375,25 +5375,13 @@ void Application::loadSettings() {
}
}
if (_firstRun.get()) {
// If this is our first run, evalute the Platform Tier and assign the matching Performance profile by default.
// A bunch of Performance, Simulation and Render settings will be set to a matching default value from this
// Load settings of the RenderScritpingInterface
// Do that explicitely before being used
RenderScriptingInterface::getInstance()->loadSettings();
// Here is the mapping between pelatformTIer and performance profile
const std::array<PerformanceManager::PerformancePreset, platform::Profiler::NumTiers> platformToPerformancePresetMap = {{
PerformanceManager::PerformancePreset::MID, // platform::Profiler::UNKNOWN
PerformanceManager::PerformancePreset::LOW, // platform::Profiler::LOW
PerformanceManager::PerformancePreset::MID, // platform::Profiler::MID
PerformanceManager::PerformancePreset::HIGH // platform::Profiler::HIGH
}};
// What is our profile?
auto platformTier = platform::Profiler::profilePlatform();
// Then let's assign the performance preset setting from it
getPerformanceManager().setPerformancePreset(platformToPerformancePresetMap[platformTier]);
}
// Setup the PerformanceManager which will enforce the several settings to match the Preset
// On the first run, the Preset is evaluated from the
getPerformanceManager().setupPerformancePresetSettings(_firstRun.get());
// finish initializing the camera, based on everything we checked above. Third person camera will be used if no settings
// dictated that we should be in first person

30
interface/src/PerformanceManager.cpp
View file

@ -10,10 +10,34 @@
//
#include "PerformanceManager.h"
#include <platform/Profiler.h>
#include "scripting/RenderScriptingInterface.h"
PerformanceManager::PerformanceManager()
{
setPerformancePreset((PerformancePreset) _performancePresetSetting.get());
}
void PerformanceManager::setupPerformancePresetSettings(bool evaluatePlatformTier) {
if (evaluatePlatformTier || (getPerformancePreset() == UNKNOWN)) {
// If evaluatePlatformTier, evalute the Platform Tier and assign the matching Performance profile by default.
// A bunch of Performance, Simulation and Render settings will be set to a matching default value from this
// Here is the mapping between pelatformTIer and performance profile
const std::array<PerformanceManager::PerformancePreset, platform::Profiler::NumTiers> platformToPerformancePresetMap = { {
PerformanceManager::PerformancePreset::MID, // platform::Profiler::UNKNOWN
PerformanceManager::PerformancePreset::LOW, // platform::Profiler::LOW
PerformanceManager::PerformancePreset::MID, // platform::Profiler::MID
PerformanceManager::PerformancePreset::HIGH // platform::Profiler::HIGH
} };
// What is our profile?
auto platformTier = platform::Profiler::profilePlatform();
// Then let's assign the performance preset setting from it
setPerformancePreset(platformToPerformancePresetMap[platformTier]);
}
}
void PerformanceManager::setPerformancePreset(PerformanceManager::PerformancePreset preset) {
@ -27,7 +51,7 @@ void PerformanceManager::setPerformancePreset(PerformanceManager::PerformancePre
}
PerformanceManager::PerformancePreset PerformanceManager::getPerformancePreset() const {
PerformancePreset preset = PerformancePreset::MID;
PerformancePreset preset = PerformancePreset::UNKNOWN;
preset = (PerformancePreset) _performancePresetSettingLock.resultWithReadLock<int>([&] {
return _performancePresetSetting.get();
@ -42,7 +66,7 @@ void PerformanceManager::applyPerformancePreset(PerformanceManager::PerformanceP
case PerformancePreset::HIGH:
RenderScriptingInterface::getInstance()->setRenderMethod(RenderScriptingInterface::RenderMethod::DEFERRED);
RenderScriptingInterface::getInstance()->setShadowsEnabled(true);
qApp->getRefreshRateManager().setRefreshRateProfile(RefreshRateManager::RefreshRateProfile::INTERACTIVE);
qApp->getRefreshRateManager().setRefreshRateProfile(RefreshRateManager::RefreshRateProfile::REALTIME);
break;
case PerformancePreset::MID:
@ -57,7 +81,9 @@ void PerformanceManager::applyPerformancePreset(PerformanceManager::PerformanceP
qApp->getRefreshRateManager().setRefreshRateProfile(RefreshRateManager::RefreshRateProfile::ECO);
break;
case PerformancePreset::UNKNOWN:
default:
// Do nothing anymore
break;
}
}

9
interface/src/PerformanceManager.h
View file

@ -20,7 +20,8 @@
class PerformanceManager {
public:
enum PerformancePreset {
LOW = 0,
UNKNOWN = 0, // Matching the platform Tier profiles enumeration for coherence
LOW,
MID,
HIGH,
PROFILE_COUNT
@ -29,12 +30,16 @@ public:
PerformanceManager();
~PerformanceManager() = default;
// Setup the PerformanceManager which will enforce the several settings to match the Preset
// If evaluatePlatformTier is true, the Preset is evaluated from the Platform::Profiler::profilePlatform()
void setupPerformancePresetSettings(bool evaluatePlatformTier);
void setPerformancePreset(PerformancePreset performancePreset);
PerformancePreset getPerformancePreset() const;
private:
mutable ReadWriteLockable _performancePresetSettingLock;
Setting::Handle<int> _performancePresetSetting { "performancePreset", PerformanceManager::PerformancePreset::MID };
Setting::Handle<int> _performancePresetSetting { "performancePreset", PerformanceManager::PerformancePreset::UNKNOWN };
// The concrete performance preset changes
void applyPerformancePreset(PerformanceManager::PerformancePreset performancePreset);

6
interface/src/scripting/PerformanceScriptingInterface.cpp
View file

@ -21,6 +21,7 @@ PerformanceScriptingInterface::PerformanceScriptingInterface() {
void PerformanceScriptingInterface::setPerformancePreset(PerformancePreset performancePreset) {
qApp->getPerformanceManager().setPerformancePreset((PerformanceManager::PerformancePreset)performancePreset);
emit settingsChanged();
}
PerformanceScriptingInterface::PerformancePreset PerformanceScriptingInterface::getPerformancePreset() const {
@ -28,12 +29,13 @@ PerformanceScriptingInterface::PerformancePreset PerformanceScriptingInterface::
}
QStringList PerformanceScriptingInterface::getPerformancePresetNames() const {
static const QStringList performancePresetNames = { "Low", "Mid", "High" };
static const QStringList performancePresetNames = { "UNKNOWN", "LOW", "MID", "HIGH" };
return performancePresetNames;
}
void PerformanceScriptingInterface::setRefreshRateProfile(RefreshRateProfile refreshRateProfile) {
qApp->getRefreshRateManager().setRefreshRateProfile((RefreshRateManager::RefreshRateProfile)refreshRateProfile);
emit settingsChanged();
}
PerformanceScriptingInterface::RefreshRateProfile PerformanceScriptingInterface::getRefreshRateProfile() const {
@ -41,7 +43,7 @@ PerformanceScriptingInterface::RefreshRateProfile PerformanceScriptingInterface:
}
QStringList PerformanceScriptingInterface::getRefreshRateProfileNames() const {
static const QStringList refreshRateProfileNames = { "Eco", "Interactive", "Realtime" };
static const QStringList refreshRateProfileNames = { "ECO", "INTERACTIVE", "REALTIME" };
return refreshRateProfileNames;
}

7
interface/src/scripting/PerformanceScriptingInterface.h
View file

@ -20,10 +20,14 @@
class PerformanceScriptingInterface : public QObject {
Q_OBJECT
Q_PROPERTY(PerformancePreset performancePreset READ getPerformancePreset WRITE setPerformancePreset NOTIFY settingsChanged)
Q_PROPERTY(RefreshRateProfile refreshRateProfile READ getRefreshRateProfile WRITE setRefreshRateProfile NOTIFY settingsChanged)
public:
// PerformanceManager PerformancePreset tri state level enums
enum PerformancePreset {
UNKNOWN = PerformanceManager::PerformancePreset::UNKNOWN,
LOW = PerformanceManager::PerformancePreset::LOW,
MID = PerformanceManager::PerformancePreset::MID,
HIGH = PerformanceManager::PerformancePreset::HIGH,
@ -55,6 +59,9 @@ public slots:
RefreshRateManager::UXMode getUXMode() const;
RefreshRateManager::RefreshRateRegime getRefreshRateRegime() const;
signals:
void settingsChanged();
private:
static std::once_flag registry_flag;
};

8
interface/src/scripting/PlatformInfoScriptingInterface.h
View file

@ -186,8 +186,8 @@ public slots:
/**jsdoc
* Get the Platform TIer profiled on startup of the Computer
* Platform Tier is an ineger/enum value:
* LOW = 0, MID = 1, HIGH = 2
* Platform Tier is an integer/enum value:
* UNKNOWN = 0, LOW = 1, MID = 2, HIGH = 3
* @function PlatformInfo.getTierProfiled
* @returns {number} The Platform Tier profiled on startup.
*/
@ -195,8 +195,8 @@ public slots:
/**jsdoc
* Get the Platform Tier possible Names as an array of strings
* Platform Tier is an ineger/enum value:
* LOW = 0, MID = 1, HIGH = 2
* Platform Tier names are:
* [ "UNKNOWN", "LOW", "MID", "HIGH" ]
* @function PlatformInfo.getPlatformTierNames
* @returns {string} The array of names matching the number returned from PlatformInfo.getTierProfiled
*/

162
interface/src/scripting/RenderScriptingInterface.cpp
View file

@ -10,118 +10,138 @@
#include "LightingModel.h"
#include "AntialiasingEffect.h"
const QString DEFERRED = "deferred";
const QString FORWARD = "forward";
RenderScriptingInterface* RenderScriptingInterface::getInstance() {
static RenderScriptingInterface sharedInstance;
return &sharedInstance;
}
std::once_flag RenderScriptingInterface::registry_flag;
RenderScriptingInterface::RenderScriptingInterface() {
setRenderMethod((RenderMethod)_renderMethodSetting.get() == RenderMethod::DEFERRED ? RenderMethod::DEFERRED : RenderMethod::FORWARD);
setShadowsEnabled(_shadowsEnabledSetting.get());
setAmbientOcclusionEnabled(_ambientOcclusionEnabledSetting.get());
setAntialiasingEnabled(_antialiasingEnabledSetting.get());
std::call_once(registry_flag, [] {
qmlRegisterType<RenderScriptingInterface>("RenderEnums", 1, 0, "RenderEnums");
});
}
void RenderScriptingInterface::loadSettings() {
_renderSettingLock.withReadLock([&] {
_renderMethod = (_renderMethodSetting.get());
_shadowsEnabled = (_shadowsEnabledSetting.get());
_ambientOcclusionEnabled = (_ambientOcclusionEnabledSetting.get());
_antialiasingEnabled = (_antialiasingEnabledSetting.get());
});
forceRenderMethod((RenderMethod)_renderMethod);
forceShadowsEnabled(_shadowsEnabled);
forceAmbientOcclusionEnabled(_ambientOcclusionEnabled);
forceAntialiasingEnabled(_antialiasingEnabled);
}
RenderScriptingInterface::RenderMethod RenderScriptingInterface::getRenderMethod() {
return (RenderMethod)_renderMethodSetting.get() == RenderMethod::DEFERRED ? RenderMethod::DEFERRED : RenderMethod::FORWARD;
return (RenderMethod) _renderMethod;
}
void RenderScriptingInterface::setRenderMethod(RenderScriptingInterface::RenderMethod renderMethod) {
RenderMethod newMethod = renderMethod == RenderMethod::FORWARD ? RenderMethod::FORWARD : RenderMethod::DEFERRED;
if (_renderMethodSetting.get() == newMethod) {
return;
void RenderScriptingInterface::setRenderMethod(RenderMethod renderMethod) {
if (_renderMethod != (int) renderMethod) {
forceRenderMethod(renderMethod);
emit settingsChanged();
}
}
void RenderScriptingInterface::forceRenderMethod(RenderMethod renderMethod) {
_renderSettingLock.withWriteLock([&] {
_renderMethod = (int)renderMethod;
_renderMethodSetting.set((int)renderMethod);
if (QThread::currentThread() != thread()) {
QMetaObject::invokeMethod(this, "setRenderMethod", Q_ARG(RenderScriptingInterface::RenderMethod, renderMethod));
return;
}
auto config = dynamic_cast<task::SwitchConfig*>(qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.DeferredForwardSwitch"));
if (config) {
_renderMethodSetting.set(newMethod);
config->setBranch(newMethod);
emit config->dirtyEnabled();
}
auto config = dynamic_cast<task::SwitchConfig*>(qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.DeferredForwardSwitch"));
if (config) {
config->setBranch((int)renderMethod);
}
});
}
QStringList RenderScriptingInterface::getRenderMethodNames() const {
static const QStringList refrenderMethodNames = { "Deferred", "Forward" };
static const QStringList refrenderMethodNames = { "DEFERRED", "FORWARD" };
return refrenderMethodNames;
}
bool RenderScriptingInterface::getShadowsEnabled() {
return _shadowsEnabledSetting.get();
return _shadowsEnabled;
}
void RenderScriptingInterface::setShadowsEnabled(bool enabled) {
if (_shadowsEnabledSetting.get() == enabled) {
return;
if (_shadowsEnabled != enabled) {
forceShadowsEnabled(enabled);
emit settingsChanged();
}
}
if (QThread::currentThread() != thread()) {
QMetaObject::invokeMethod(this, "setShadowsEnabled", Q_ARG(bool, enabled));
return;
}
auto lightingModelConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<MakeLightingModel>("RenderMainView.LightingModel");
if (lightingModelConfig) {
Menu::getInstance()->setIsOptionChecked(MenuOption::Shadows, enabled);
void RenderScriptingInterface::forceShadowsEnabled(bool enabled) {
_renderSettingLock.withWriteLock([&] {
_shadowsEnabled = (enabled);
_shadowsEnabledSetting.set(enabled);
lightingModelConfig->setShadow(enabled);
}
auto lightingModelConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<MakeLightingModel>("RenderMainView.LightingModel");
if (lightingModelConfig) {
Menu::getInstance()->setIsOptionChecked(MenuOption::Shadows, enabled);
lightingModelConfig->setShadow(enabled);
}
});
}
bool RenderScriptingInterface::getAmbientOcclusionEnabled() {
return _ambientOcclusionEnabledSetting.get();
return _ambientOcclusionEnabled;
}
void RenderScriptingInterface::setAmbientOcclusionEnabled(bool enabled) {
if (_ambientOcclusionEnabledSetting.get() == enabled) {
return;
if (_ambientOcclusionEnabled != enabled) {
forceAmbientOcclusionEnabled(enabled);
emit settingsChanged();
}
}
if (QThread::currentThread() != thread()) {
QMetaObject::invokeMethod(this, "setAmbientOcclusionEnabled", Q_ARG(bool, enabled));
return;
}
auto lightingModelConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<MakeLightingModel>("RenderMainView.LightingModel");
if (lightingModelConfig) {
Menu::getInstance()->setIsOptionChecked(MenuOption::AmbientOcclusion, enabled);
void RenderScriptingInterface::forceAmbientOcclusionEnabled(bool enabled) {
_renderSettingLock.withWriteLock([&] {
_ambientOcclusionEnabled = (enabled);
_ambientOcclusionEnabledSetting.set(enabled);
lightingModelConfig->setAmbientOcclusion(enabled);
}
auto lightingModelConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<MakeLightingModel>("RenderMainView.LightingModel");
if (lightingModelConfig) {
Menu::getInstance()->setIsOptionChecked(MenuOption::AmbientOcclusion, enabled);
lightingModelConfig->setAmbientOcclusion(enabled);
}
});
}
bool RenderScriptingInterface::getAntialiasingEnabled() {
return _antialiasingEnabledSetting.get();
return _antialiasingEnabled;
}
void RenderScriptingInterface::setAntialiasingEnabled(bool enabled) {
if (_antialiasingEnabledSetting.get() == enabled) {
return;
}
if (QThread::currentThread() != thread()) {
QMetaObject::invokeMethod(this, "setAntialiasingEnabled", Q_ARG(bool, enabled));
return;
}
auto mainViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<JitterSample>("RenderMainView.JitterCam");
auto mainViewAntialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<Antialiasing>("RenderMainView.Antialiasing");
if (mainViewJitterCamConfig && mainViewAntialiasingConfig) {
Menu::getInstance()->setIsOptionChecked(MenuOption::AntiAliasing, enabled);
_antialiasingEnabledSetting.set(enabled);
if (enabled) {
mainViewJitterCamConfig->play();
mainViewAntialiasingConfig->setDebugFXAA(false);
} else {
mainViewJitterCamConfig->none();
mainViewAntialiasingConfig->setDebugFXAA(true);
}
if (_antialiasingEnabled != enabled) {
forceAntialiasingEnabled(enabled);
emit settingsChanged();
}
}
void RenderScriptingInterface::forceAntialiasingEnabled(bool enabled) {
_renderSettingLock.withWriteLock([&] {
_antialiasingEnabled = (enabled);
_antialiasingEnabledSetting.set(enabled);
auto mainViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<JitterSample>("RenderMainView.JitterCam");
auto mainViewAntialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<Antialiasing>("RenderMainView.Antialiasing");
if (mainViewJitterCamConfig && mainViewAntialiasingConfig) {
Menu::getInstance()->setIsOptionChecked(MenuOption::AntiAliasing, enabled);
if (enabled) {
mainViewJitterCamConfig->play();
mainViewAntialiasingConfig->setDebugFXAA(false);
}
else {
mainViewJitterCamConfig->none();
mainViewAntialiasingConfig->setDebugFXAA(true);
}
}
});
}

40
interface/src/scripting/RenderScriptingInterface.h
View file

@ -25,10 +25,10 @@
*/
class RenderScriptingInterface : public QObject {
Q_OBJECT
Q_PROPERTY(RenderMethod renderMethod READ getRenderMethod WRITE setRenderMethod)
Q_PROPERTY(bool shadowsEnabled READ getShadowsEnabled WRITE setShadowsEnabled)
Q_PROPERTY(bool ambientOcclusionEnabled READ getAmbientOcclusionEnabled WRITE setAmbientOcclusionEnabled)
Q_PROPERTY(bool antialiasingEnabled READ getAntialiasingEnabled WRITE setAntialiasingEnabled)
Q_PROPERTY(RenderMethod renderMethod READ getRenderMethod WRITE setRenderMethod NOTIFY settingsChanged)
Q_PROPERTY(bool shadowsEnabled READ getShadowsEnabled WRITE setShadowsEnabled NOTIFY settingsChanged)
Q_PROPERTY(bool ambientOcclusionEnabled READ getAmbientOcclusionEnabled WRITE setAmbientOcclusionEnabled NOTIFY settingsChanged)
Q_PROPERTY(bool antialiasingEnabled READ getAntialiasingEnabled WRITE setAntialiasingEnabled NOTIFY settingsChanged)
public:
RenderScriptingInterface();
@ -36,11 +36,17 @@ public:
static RenderScriptingInterface* getInstance();
// RenderMethod enum type
enum RenderMethod {
enum class RenderMethod {
DEFERRED = render::Args::RenderMethod::DEFERRED,
FORWARD = render::Args::RenderMethod::FORWARD,
};
Q_ENUM(RenderMethod);
Q_ENUM(RenderMethod)
// Load Settings
// Synchronize the runtime value to the actual setting
// Need to be called on start up to re-initialize the runtime to the saved setting states
void loadSettings();
public slots:
/**jsdoc
@ -132,12 +138,32 @@ public slots:
*/
// void setViewportResolutionScale(float resolutionScale);
signals:
void settingsChanged();
private:
// One lock to serialize and access safely all the settings
mutable ReadWriteLockable _renderSettingLock;
// Runtime value of each settings
int _renderMethod{ RENDER_FORWARD ? render::Args::RenderMethod::FORWARD : render::Args::RenderMethod::DEFERRED };
bool _shadowsEnabled{ true };
bool _ambientOcclusionEnabled{ false };
bool _antialiasingEnabled { true };
// Actual settings saved on disk
Setting::Handle<int> _renderMethodSetting { "renderMethod", RENDER_FORWARD ? render::Args::RenderMethod::FORWARD : render::Args::RenderMethod::DEFERRED };
Setting::Handle<bool> _shadowsEnabledSetting { "shadowsEnabled", true };
Setting::Handle<bool> _ambientOcclusionEnabledSetting { "ambientOcclusionEnabled", false };
Setting::Handle<bool> _antialiasingEnabledSetting { "antialiasingEnabled", true };
Setting::Handle<float> _viewportResolutionScaleSetting{ "viewportResolutionScale", 1.0f };
// Force assign both setting AND runtime value to the parameter value
void forceRenderMethod(RenderMethod renderMethod);
void forceShadowsEnabled(bool enabled);
void forceAmbientOcclusionEnabled(bool enabled);
void forceAntialiasingEnabled(bool enabled);
static std::once_flag registry_flag;
};
#endif // hifi_RenderScriptingInterface_h

7
scripts/developer/utilities/lib/jet/qml/TaskPropView.qml
View file

@ -75,7 +75,12 @@ Prop.PropGroup {
filled: root.jobEnabled
fillColor: (root.jobEnabled ? global.colorGreenHighlight : global.colorOrangeAccent)
icon: 5
iconMouseArea.onClicked: { toggleJobActivation() }
MouseArea{
id: mousearea
anchors.fill: parent
onClicked: { root.toggleJobActivation() }
}
}
}

2
scripts/developer/utilities/lib/prop/PropEnum.qml
View file

@ -19,7 +19,7 @@ PropItem {
property alias enums : valueCombo.model
Component.onCompleted: {
// valueVar = root.valueVarGetter();
valueVar = root.valueVarGetter();
}
PropComboBox {

1
scripts/developer/utilities/lib/prop/style/Global.qml
View file

@ -29,6 +29,7 @@ Item {
readonly property color colorBackHighlight: hifi.colors.baseGrayHighlight
readonly property color colorBorderLight: hifi.colors.lightGray
readonly property color colorBorderHighight: hifi.colors.blueHighlight
readonly property color colorBorderLighter: hifi.colors.faintGray
readonly property color colorOrangeAccent: "#FF6309"
readonly property color colorRedAccent: "#C62147"

22
scripts/developer/utilities/lib/prop/style/PiCanvasIcon.qml
View file

@ -29,11 +29,19 @@ Canvas {
}
property var fillColor: global.colorBorderHighight
onFillColorChanged: function () { //console.log("fillColor changed to: " + filled );
onFillColorChanged: function () { //console.log("fillColor changed to: " + fillColor );
requestPaint()
}
property alias iconMouseArea: mousearea
property var stroked: true
onStrokedChanged: function () { //console.log("Stroked changed to: " + stroked );
requestPaint()
}
property var strokeColor: global.colorBorderLight
onStrokeColorChanged: function () { //console.log("strokeColor changed to: " + strokeColor );
requestPaint()
}
contextType: "2d"
onPaint: {
@ -86,14 +94,10 @@ Canvas {
if (filled) {
context.fillStyle = fillColor;
context.fill();
} else {
context.strokeStyle = fillColor;
}
if (stroked) {
context.strokeStyle = strokeColor;
context.stroke();
}
}
MouseArea{
id: mousearea
anchors.fill: parent
}
}

46
scripts/developer/utilities/lib/prop/style/PiCheckBox.qml
View file

@ -9,15 +9,47 @@
//
import QtQuick 2.7
import controlsUit 1.0 as HifiControls
import QtQuick.Controls 2.2
HifiControls.CheckBox {
CheckBox {
Global { id: global }
color: global.fontColor
id: control
text: ""
checked: true
spacing: 0
//anchors.left: root.splitter.right
//anchors.verticalCenter: root.verticalCenter
//width: root.width * global.valueAreaWidthScale
indicator: Rectangle {
color: global.colorBack
border.color: control.down ? global.colorBorderLighter : global.colorBorderLight
border.width: global.valueBorderWidth
radius: global.valueBorderRadius / 2
anchors.left: parent.left
anchors.verticalCenter: parent.verticalCenter
implicitWidth: global.iconWidth
implicitHeight: global.iconWidth
Rectangle {
visible: control.checked
color: global.colorBorderHighight
radius: global.valueBorderRadius / 4
anchors.horizontalCenter: parent.horizontalCenter
anchors.verticalCenter: parent.verticalCenter
implicitWidth: global.iconWidth - 2
implicitHeight: global.iconHeight - 2
}
}
contentItem: PiText {
text: control.text
anchors.verticalCenter: parent.verticalCenter
horizontalAlignment: Text.AlignHLeft
anchors.left: control.indicator.right
leftPadding: global.horizontalMargin
}
height: global.slimHeight
}

15
scripts/developer/utilities/lib/prop/style/PiComboBox.qml
View file

@ -28,7 +28,7 @@ ComboBox {
horizontalAlignment: global.valueTextAlign
}
background: Rectangle {
color:highlighted?global.colorBackHighlight:global.color;
color:highlighted ? global.colorBackHighlight : global.colorBack;
}
highlighted: valueCombo.highlightedIndex === index
}
@ -38,11 +38,8 @@ ComboBox {
x: valueCombo.width - width - valueCombo.rightPadding
y: valueCombo.topPadding + (valueCombo.availableHeight - height) / 2
icon: 1
/*Connections {
target: valueCombo
onPressedChanged: { canvas.icon = control.down + 1 }
}*/
strokeColor: (valueCombo.down ? global.colorBorderLighter : global.colorBorderLight )
icon: 1 + valueCombo.down
}
contentItem: PiText {
@ -56,8 +53,8 @@ ComboBox {
background: Rectangle {
implicitWidth: 120
implicitHeight: 40
color: global.color
border.color: valueCombo.popup.visible ? global.colorBorderHighight : global.colorBorderLight
color: global.colorBack
border.color: valueCombo.popup.visible ? global.colorBorderLighter : global.colorBorderLight
border.width: global.valueBorderWidth
radius: global.valueBorderRadius
}
@ -78,7 +75,7 @@ ComboBox {
}
background: Rectangle {
color: global.color
color: global.colorBack
border.color: global.colorBorderHighight
radius: global.valueBorderRadius
}

7
scripts/developer/utilities/lib/prop/style/PiFolderPanel.qml
View file

@ -72,7 +72,12 @@ Item {
anchors.horizontalCenter: parent.horizontalCenter
anchors.verticalCenter: parent.verticalCenter
fillColor: global.colorOrangeAccent
iconMouseArea.onClicked: { root.isUnfold = !root.isUnfold }
MouseArea{
id: mousearea
anchors.fill: parent
onClicked: { root.isUnfold = !root.isUnfold }
}
}
}

11
scripts/developer/utilities/render/luci/PerformanceSettings.qml
View file

@ -19,7 +19,6 @@ Column {
Prop.PropString {
label: "Platform Tier"
//object: Performance
valueVarSetter: function (v) {}
valueVarGetter: function () {
return PlatformInfo.getPlatformTierNames()[PlatformInfo.getTierProfiled()]; }
@ -27,17 +26,15 @@ Column {
Prop.PropEnum {
label: "Performance Preset"
//object: Performance
valueVarSetter: Performance.setPerformancePreset
valueVarGetter: Performance.getPerformancePreset
object: Performance
property: "performancePreset"
enums: Performance.getPerformancePresetNames()
}
Prop.PropEnum {
label: "Refresh Rate Profile"
//object: Performance
valueVarSetter: Performance.setRefreshRateProfile
valueVarGetter: Performance.getRefreshRateProfile
object: Performance
property: "refreshRateProfile"
enums: Performance.getRefreshRateProfileNames()
}
}

3
scripts/developer/utilities/render/luci/Platform.qml
View file

@ -16,7 +16,8 @@ import controlsUit 1.0 as HifiControls
import "../../lib/prop" as Prop
Column {
width: parent.width
anchors.left: parent.left
anchors.right: parent.right
Prop.PropGroup {
id: computer

53
scripts/developer/utilities/render/performanceSetup.qml
View file

@ -24,33 +24,42 @@ Rectangle {
color: global.colorBack
ScrollView {
anchors.fill: parent
anchors.fill: parent
clip: true
Column {
anchors.left: parent.left
anchors.right: parent.right
Column {
anchors.left: parent.left
anchors.right: parent.right
Prop.PropFolderPanel {
label: "Performance Settings"
isUnfold: true
panelFrameData: Component {
PerformanceSettings {}
Prop.PropFolderPanel {
label: "Performance Settings"
isUnfold: true
panelFrameData: Component {
PerformanceSettings {
anchors.left: parent.left
anchors.right: parent.right
}
}
}
}
Prop.PropFolderPanel {
label: "Render Settings"
isUnfold: true
panelFrameData: Component {
RenderSettings {}
Prop.PropFolderPanel {
label: "Render Settings"
isUnfold: true
panelFrameData: Component {
RenderSettings {
anchors.left: parent.left
anchors.right: parent.right
}
}
}
/* Prop.PropFolderPanel {
label: "Platform"
panelFrameData: Component {
Platform {
anchors.left: parent.left
anchors.right: parent.right
}
}
}*/
}
Prop.PropFolderPanel {
label: "Platform"
panelFrameData: Component {
Platform {}
}
}
}
}
}