Addressing the initialization bug not applying REnderMethod properly, Adjusting RefrehRateProfile to Realtime in High performancePreset

interface/src/Application.cpp

@@ -5375,6 +5375,10 @@ void Application::loadSettings() {
         }
     }
 
+    // Load settings of the RenderScritpingInterface
+    // Do that explicitely before being used
+    RenderScriptingInterface::getInstance()->loadSettings();
+
     // 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());

interface/src/PerformanceManager.cpp

@@ -66,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:

interface/src/scripting/PerformanceScriptingInterface.cpp

@@ -21,6 +21,7 @@ PerformanceScriptingInterface::PerformanceScriptingInterface() {
 
 void PerformanceScriptingInterface::setPerformancePreset(PerformancePreset performancePreset) {
     qApp->getPerformanceManager().setPerformancePreset((PerformanceManager::PerformancePreset)performancePreset);
+    emit settingsChanged();
 }
 
 PerformanceScriptingInterface::PerformancePreset PerformanceScriptingInterface::getPerformancePreset() const {
@@ -34,6 +35,7 @@ QStringList PerformanceScriptingInterface::getPerformancePresetNames() const {
 
 void PerformanceScriptingInterface::setRefreshRateProfile(RefreshRateProfile refreshRateProfile) {
     qApp->getRefreshRateManager().setRefreshRateProfile((RefreshRateManager::RefreshRateProfile)refreshRateProfile);
+    emit settingsChanged();
 }
 
 PerformanceScriptingInterface::RefreshRateProfile PerformanceScriptingInterface::getRefreshRateProfile() const {

interface/src/scripting/PerformanceScriptingInterface.h

@@ -20,6 +20,9 @@
 
 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
@@ -56,6 +59,9 @@ public slots:
     RefreshRateManager::UXMode getUXMode() const;
     RefreshRateManager::RefreshRateRegime getRefreshRateRegime() const;
 
+signals:
+    void settingsChanged();
+
 private:
     static std::once_flag registry_flag;
 };

interface/src/scripting/RenderScriptingInterface.cpp

@@ -21,34 +21,43 @@ RenderScriptingInterface::RenderScriptingInterface() {
     std::call_once(registry_flag, [] {
         qmlRegisterType<RenderScriptingInterface>("RenderEnums", 1, 0, "RenderEnums");
     });
+}
 
-    setRenderMethod((RenderMethod)_renderMethodSettingLock.resultWithReadLock<int>([&] {
+void RenderScriptingInterface::loadSettings() {
-        return _renderMethodSetting.get();
+    _renderSettingLock.withReadLock([&] {
-    }));
+        _renderMethod.store(_renderMethodSetting.get());
-    setShadowsEnabled(_shadowsEnabledSetting.get());
+        _shadowsEnabled.store(_shadowsEnabledSetting.get());
-    setAmbientOcclusionEnabled(_ambientOcclusionEnabledSetting.get());
+        _ambientOcclusionEnabled.store(_ambientOcclusionEnabledSetting.get());
-    setAntialiasingEnabled(_antialiasingEnabledSetting.get());
+        _antialiasingEnabled.store(_antialiasingEnabledSetting.get());
+    });
+    forceRenderMethod((RenderMethod)_renderMethod.load());
+    forceShadowsEnabled(_shadowsEnabled.load());
+    forceAmbientOcclusionEnabled(_ambientOcclusionEnabled.load());
+    forceAntialiasingEnabled(_antialiasingEnabled.load());
 }
 
 RenderScriptingInterface::RenderMethod RenderScriptingInterface::getRenderMethod() {
-    return (RenderMethod) _renderMethod;
+    return (RenderMethod) _renderMethod.load();
 }
 
 void RenderScriptingInterface::setRenderMethod(RenderMethod renderMethod) {
     if (_renderMethod != (int) renderMethod) {
-        _renderMethodSettingLock.withWriteLock([&] {
+        forceRenderMethod(renderMethod);
-            _renderMethod = (int)renderMethod;
-            _renderMethodSetting.set((int)renderMethod);
-
-            auto config = dynamic_cast<task::SwitchConfig*>(qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.DeferredForwardSwitch"));
-            if (config) {
-                _renderMethodSetting.set((int)renderMethod);
-                config->setBranch((int)renderMethod);
-            }
-        });
         emit settingsChanged();
     }
 }
+void RenderScriptingInterface::forceRenderMethod(RenderMethod renderMethod) {
+    _renderSettingLock.withWriteLock([&] {
+        _renderMethod = (int)renderMethod;
+        _renderMethodSetting.set((int)renderMethod);
+
+        auto config = dynamic_cast<task::SwitchConfig*>(qApp->getRenderEngine()->getConfiguration()->getConfig("RenderMainView.DeferredForwardSwitch"));
+        if (config) {
+            _renderMethodSetting.set((int)renderMethod);
+            config->setBranch((int)renderMethod);
+        }
+    });
+}
 
 QStringList RenderScriptingInterface::getRenderMethodNames() const {
     static const QStringList refrenderMethodNames = { "DEFERRED", "FORWARD" };
@@ -56,78 +65,83 @@ QStringList RenderScriptingInterface::getRenderMethodNames() const {
 }
 
 bool RenderScriptingInterface::getShadowsEnabled() {
-    return _shadowsEnabledSetting.get();
+    return _shadowsEnabled.load();
 }
 
 void RenderScriptingInterface::setShadowsEnabled(bool enabled) {
-    if (_shadowsEnabledSetting.get() == enabled) {
+    if (_shadowsEnabled != enabled) {
-        return;
+        forceShadowsEnabled(enabled);
-    }
-
-    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);
-        _shadowsEnabledSetting.set(enabled);
-        lightingModelConfig->setShadow(enabled);
         emit settingsChanged();
     }
 }
 
+void RenderScriptingInterface::forceShadowsEnabled(bool enabled) {
+    _renderSettingLock.withWriteLock([&] {
+        _shadowsEnabled.store(enabled);
+        _shadowsEnabledSetting.set(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.load();
 }
 
 void RenderScriptingInterface::setAmbientOcclusionEnabled(bool enabled) {
-    if (_ambientOcclusionEnabledSetting.get() == enabled) {
+    if (_ambientOcclusionEnabled.load() != enabled) {
-        return;
+        forceAmbientOcclusionEnabled(enabled);
-    }
-
-    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);
-        _ambientOcclusionEnabledSetting.set(enabled);
-        lightingModelConfig->setAmbientOcclusion(enabled);
         emit settingsChanged();
     }
 }
 
+void RenderScriptingInterface::forceAmbientOcclusionEnabled(bool enabled) {
+    _renderSettingLock.withWriteLock([&] {
+        _ambientOcclusionEnabled.store(enabled);
+        _ambientOcclusionEnabledSetting.set(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.load();
 }
 
 void RenderScriptingInterface::setAntialiasingEnabled(bool enabled) {
-    if (_antialiasingEnabledSetting.get() == enabled) {
+    if (_antialiasingEnabled.load() != enabled) {
-        return;
+        forceAntialiasingEnabled(enabled);
-    }
-
-    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);
-        }
-
         emit settingsChanged();
     }
 }
+
+void RenderScriptingInterface::forceAntialiasingEnabled(bool enabled) {
+    _renderSettingLock.withWriteLock([&] {
+        _antialiasingEnabled.store(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);
+            }
+        }
+    });
+}
+
+

interface/src/scripting/RenderScriptingInterface.h

@@ -25,10 +25,10 @@
  */
 class RenderScriptingInterface : public QObject {
     Q_OBJECT
-  //  Q_PROPERTY(RenderMethod renderMethod READ getRenderMethod WRITE setRenderMethod NOTIFY settingsChanged)
+    Q_PROPERTY(RenderMethod renderMethod READ getRenderMethod WRITE setRenderMethod NOTIFY settingsChanged)
-  //  Q_PROPERTY(bool shadowsEnabled READ getShadowsEnabled WRITE setShadowsEnabled 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 ambientOcclusionEnabled READ getAmbientOcclusionEnabled WRITE setAmbientOcclusionEnabled NOTIFY settingsChanged)
-  //  Q_PROPERTY(bool antialiasingEnabled READ getAntialiasingEnabled WRITE setAntialiasingEnabled NOTIFY settingsChanged)
+    Q_PROPERTY(bool antialiasingEnabled READ getAntialiasingEnabled WRITE setAntialiasingEnabled NOTIFY settingsChanged)
 
 public:
     RenderScriptingInterface();
@@ -42,6 +42,12 @@ public:
     };
     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
      * Get a config for a job by name
@@ -136,14 +142,26 @@ signals:
     void settingsChanged();
 
 private:
-    int _renderMethod { -1 };
+    // One lock to serialize and access safely all the settings
-    mutable ReadWriteLockable _renderMethodSettingLock;
+    mutable ReadWriteLockable _renderSettingLock;
-    Setting::Handle<int> _renderMethodSetting { "renderMethod", RENDER_FORWARD ? render::Args::RenderMethod::FORWARD : render::Args::RenderMethod::DEFERRED };
 
+    // Runtime atomic value of each settings
+    std::atomic_int  _renderMethod{ render::Args::RenderMethod::DEFERRED };
+    std::atomic_bool _shadowsEnabled{ true };
+    std::atomic_bool _ambientOcclusionEnabled{ false };
+    std::atomic_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;
 };

scripts/developer/utilities/lib/jet/qml/TaskPropView.qml

@@ -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() }
+                }
             }
 
         }

scripts/developer/utilities/lib/prop/PropEnum.qml

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

scripts/developer/utilities/lib/prop/style/Global.qml

@@ -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"

scripts/developer/utilities/lib/prop/style/PiCanvasIcon.qml

@@ -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
-    }
 }

scripts/developer/utilities/lib/prop/style/PiCheckBox.qml

@@ -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 }
-    
+    id: control
-    color: global.fontColor
+    text: ""
+    checked: true
+    spacing: 0
 
-    //anchors.left: root.splitter.right
+    indicator: Rectangle {
-    //anchors.verticalCenter: root.verticalCenter
+        color: global.colorBack  
-    //width: root.width * global.valueAreaWidthScale
+        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
 }

scripts/developer/utilities/lib/prop/style/PiComboBox.qml

@@ -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
+        strokeColor: (valueCombo.down ? global.colorBorderLighter : global.colorBorderLight )
-        /*Connections {
+        icon: 1 + valueCombo.down
-            target: valueCombo
-            onPressedChanged: { canvas.icon = control.down + 1 }
-        }*/
     }
 
     contentItem: PiText {
@@ -56,8 +53,8 @@ ComboBox {
     background: Rectangle {
         implicitWidth: 120
         implicitHeight: 40
-        color: global.color
+        color: global.colorBack
-        border.color: valueCombo.popup.visible ? global.colorBorderHighight : global.colorBorderLight
+        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
         }

scripts/developer/utilities/lib/prop/style/PiFolderPanel.qml

@@ -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 }
+                }
             }
         }
 

scripts/developer/utilities/render/luci/PerformanceSettings.qml

@@ -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
+        object: Performance
-        valueVarSetter: Performance.setPerformancePreset 
+        property: "performancePreset"
-        valueVarGetter: Performance.getPerformancePreset 
         enums: Performance.getPerformancePresetNames()
     }
 
     Prop.PropEnum {
         label: "Refresh Rate Profile"
-        //object: Performance
+        object: Performance
-        valueVarSetter: Performance.setRefreshRateProfile 
+        property: "refreshRateProfile"
-        valueVarGetter: Performance.getRefreshRateProfile 
         enums: Performance.getRefreshRateProfileNames()
     }
 }

scripts/developer/utilities/render/luci/Platform.qml

@@ -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

scripts/developer/utilities/render/performanceSetup.qml

@@ -24,33 +24,42 @@ Rectangle {
     color: global.colorBack
 
     ScrollView {
-    anchors.fill: parent 
+        anchors.fill: parent 
         clip: true
-    Column {    
+        Column {    
-        anchors.left: parent.left 
+            anchors.left: parent.left 
-        anchors.right: parent.right 
+            anchors.right: parent.right 
 
-        Prop.PropFolderPanel {
+            Prop.PropFolderPanel {
-            label: "Performance Settings"
+                label: "Performance Settings"
-            isUnfold: true
+                isUnfold: true
-            panelFrameData: Component {
+                panelFrameData: Component {
-                PerformanceSettings {}
+                    PerformanceSettings {
+                        anchors.left: parent.left 
+                        anchors.right: parent.right 
+                    }
+                }
             }
-        }
+            Prop.PropFolderPanel {
-        Prop.PropFolderPanel {
+                label: "Render Settings"
-            label: "Render Settings"
+                isUnfold: true
-            isUnfold: true
+                panelFrameData: Component {
-            panelFrameData: Component {
+                    RenderSettings {
-                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 {}
-            }
-        }
-    }
     }
 }