////  Created by Sam Gondelman on 5/16/19//  Copyright 2013-2019 High Fidelity, Inc.//  Copyright 2023 Overte e.V.////  Distributed under the Apache License, Version 2.0.//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html//  SPDX-License-Identifier: Apache-2.0// #ifndef hifi_RenderScriptingInterface_h#define hifi_RenderScriptingInterface_h #include <QtCore/QObject>#include "Application.h" #include "RenderForward.h"#include "AntialiasingEffect.h"#include <QScreen> /*@jsdoc * The <code>Render</code> API enables you to configure the graphics engine. * * @namespace Render * * @hifi-interface * @hifi-client-entity * @hifi-avatar * * @property {Render.RenderMethod} renderMethod - The render method being used. * @property {boolean} shadowsEnabled - <code>true</code> if shadows are enabled, <code>false</code> if they're disabled. * @property {boolean} hazeEnabled - <code>true</code> if haze (fog) is enabled, <code>false</code> if it's disabled. * @property {boolean} bloomEnabled - <code>true</code> if bloom is enabled, <code>false</code> if it's disabled. * @property {boolean} ambientOcclusionEnabled - <code>true</code> if ambient occlusion is enabled, <code>false</code> if it's disabled. * @property {boolean} localLightingEnabled - <code>true</code> if local lights are enabled, * <code>false</code> if they're disabled. * @property {boolean} proceduralMaterialsEnabled - <code>true</code> if procedural shaders are enabled, <code>false</code> if *     they're disabled. * @property {integer} antialiasingMode - The active anti-aliasing mode. * @property {number} viewportResolutionScale - The view port resolution scale, <code>&gt; 0.0</code>. * @property {boolean} cameraClippingEnabled - <code>true</code> if third person camera clipping is enabled, <code>false</code> if it's disabled. */class RenderScriptingInterface : public QObject {    Q_OBJECT    Q_PROPERTY(RenderMethod renderMethod READ getRenderMethod WRITE setRenderMethod NOTIFY settingsChanged)    Q_PROPERTY(bool shadowsEnabled READ getShadowsEnabled WRITE setShadowsEnabled NOTIFY settingsChanged)    Q_PROPERTY(bool hazeEnabled READ getHazeEnabled WRITE setHazeEnabled NOTIFY settingsChanged)    Q_PROPERTY(bool bloomEnabled READ getBloomEnabled WRITE setBloomEnabled NOTIFY settingsChanged)    Q_PROPERTY(bool ambientOcclusionEnabled READ getAmbientOcclusionEnabled WRITE setAmbientOcclusionEnabled NOTIFY settingsChanged)    Q_PROPERTY(bool localLightingEnabled READ getLocalLightingEnabled WRITE setLocalLightingEnabled NOTIFY settingsChanged)    Q_PROPERTY(AntialiasingSetupConfig::Mode antialiasingMode READ getAntialiasingMode WRITE setAntialiasingMode NOTIFY settingsChanged)    Q_PROPERTY(bool proceduralMaterialsEnabled READ getProceduralMaterialsEnabled WRITE setProceduralMaterialsEnabled NOTIFY settingsChanged)    Q_PROPERTY(float viewportResolutionScale READ getViewportResolutionScale WRITE setViewportResolutionScale NOTIFY settingsChanged)    Q_PROPERTY(float verticalFieldOfView READ getVerticalFieldOfView WRITE setVerticalFieldOfView NOTIFY settingsChanged)    Q_PROPERTY(bool cameraClippingEnabled READ getCameraClippingEnabled WRITE setCameraClippingEnabled NOTIFY settingsChanged) public:    RenderScriptingInterface();     static RenderScriptingInterface* getInstance();     /*@jsdoc     * <p>The rendering method is specified by the following values:</p>     * <table>     *   <thead>     *     <tr><th>Value</th><th>Name</th><th>Description</th>     *   </thead>     *   <tbody>     *     <tr><td><code>0</code></td><td>DEFERRED</td><td>More complex rendering pipeline where lighting is applied to the     *       scene as a whole after all objects have been rendered.</td></tr>     *     <tr><td><code>1</code></td><td>FORWARD</td><td>Simpler rendering pipeline where each object in the scene, in turn,     *       is rendered and has lighting applied.</td></tr>     *   </tbody>     * </table>     * @typedef {number} Render.RenderMethod     */    // RenderMethod enum type    enum class RenderMethod {        DEFERRED = render::Args::RenderMethod::DEFERRED,        FORWARD = render::Args::RenderMethod::FORWARD,    };    Q_ENUM(RenderMethod)    static bool isValidRenderMethod(RenderMethod value) { return (value >= RenderMethod::DEFERRED && value <= RenderMethod::FORWARD); }      // 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     * Gets the configuration for a rendering job by name.     * <p><strong>Warning:</strong> For internal, debugging purposes. Subject to change.</p>     * @function Render.getConfig     * @param {string} name - The name of the rendering job.     * @returns {object} The configuration for the rendering job.     */    QObject* getConfig(const QString& name) { return qApp->getRenderEngine()->getConfiguration()->getConfig(name); }      /*@jsdoc     * Gets the render method being used.     * @function Render.getRenderMethod     * @returns {Render.RenderMethod} The render method being used.     * @example <caption>Report the current render method.</caption>     * var renderMethod = Render.getRenderMethod();     * print("Current render method: " + Render.getRenderMethodNames()[renderMethod]);     */    RenderMethod getRenderMethod() const;     /*@jsdoc     * Sets the render method to use.     * @function Render.setRenderMethod     * @param {Render.RenderMethod} renderMethod - The render method to use.     */    void setRenderMethod(RenderMethod renderMethod);     /*@jsdoc     * Gets the names of the possible render methods, per {@link Render.RenderMethod}.     * @function Render.getRenderMethodNames     * @returns {string[]} The names of the possible render methods.     * @example <caption>Report the names of the possible render methods.</caption>     * var renderMethods = Render.getRenderMethodNames();     * print("Render methods:");     * for (var i = 0; i < renderMethods.length; i++) {     *     print("- " + renderMethods[i]);     * }     */    QStringList getRenderMethodNames() const;      /*@jsdoc     * Gets whether or not shadows are enabled.     * @function Render.getShadowsEnabled     * @returns {boolean} <code>true</code> if shadows are enabled, <code>false</code> if they're disabled.     */    bool getShadowsEnabled() const;     /*@jsdoc     * Sets whether or not shadows are enabled.     * @function Render.setShadowsEnabled     * @param {boolean} enabled - <code>true</code> to enable shadows, <code>false</code> to disable.     */    void setShadowsEnabled(bool enabled);     /*@jsdoc     * Gets whether or not haze is enabled.     * @function Render.getHazeEnabled     * @returns {boolean} <code>true</code> if haze is enabled, <code>false</code> if it's disabled.     */    bool getHazeEnabled() const;     /*@jsdoc     * Sets whether or not haze is enabled.     * @function Render.setHazeEnabled     * @param {boolean} enabled - <code>true</code> to enable haze, <code>false</code> to disable.     */    void setHazeEnabled(bool enabled);     /*@jsdoc     * Gets whether or not bloom is enabled.     * @function Render.getBloomEnabled     * @returns {boolean} <code>true</code> if bloom is enabled, <code>false</code> if it's disabled.     */    bool getBloomEnabled() const;     /*@jsdoc     * Sets whether or not bloom is enabled.     * @function Render.setBloomEnabled     * @param {boolean} enabled - <code>true</code> to enable bloom, <code>false</code> to disable.     */    void setBloomEnabled(bool enabled);     /*@jsdoc     * Gets whether or not ambient occlusion is enabled.     * @function Render.getAmbientOcclusionEnabled     * @returns {boolean} <code>true</code> if ambient occlusion is enabled, <code>false</code> if it's disabled.     */    bool getAmbientOcclusionEnabled() const;     /*@jsdoc     * Sets whether or not ambient occlusion is enabled.     * @function Render.setAmbientOcclusionEnabled     * @param {boolean} enabled - <code>true</code> to enable ambient occlusion, <code>false</code> to disable.     */    void setAmbientOcclusionEnabled(bool enabled);     /*@jsdoc     * Gets whether or not local lighting is enabled.     * Ambient and key (sun) light is always enabled, regardless of this setting.     * @function Render.getLocalLightingEnabled     * @returns {boolean} <code>true</code> if local lighting is enabled, <code>false</code> if it's disabled.     */    bool getLocalLightingEnabled() const;     /*@jsdoc     * Sets whether or not local lighting is enabled.     * Ambient and key (sun) light is always enabled, regardless of this setting.     * @function Render.setLocalLightingEnabled     * @param {boolean} enabled - <code>true</code> to enable local lights, <code>false</code> to disable.     */    void setLocalLightingEnabled(bool enabled);     /*@jsdoc     * Gets whether or not procedural materials are enabled.     * @function Render.getProceduralMaterialsEnabled     * @returns {boolean} <code>true</code> if procedural materials are enabled, <code>false</code> if they're disabled.     */    bool getProceduralMaterialsEnabled() const;     /*@jsdoc     * Sets whether or not procedural materials are enabled.     * @function Render.setProceduralMaterialsEnabled     * @param {boolean} enabled - <code>true</code> to enable procedural materials, <code>false</code> to disable.     */    void setProceduralMaterialsEnabled(bool enabled);     /*@jsdoc     * Gets the active anti-aliasing mode.     * @function Render.getAntialiasingMode     * @returns {AntialiasingMode} The active anti-aliasing mode.     */    AntialiasingSetupConfig::Mode getAntialiasingMode() const;     /*@jsdoc     * Sets the active anti-aliasing mode.     * @function Render.setAntialiasingMode     * @param {AntialiasingMode} The active anti-aliasing mode.     */    void setAntialiasingMode(AntialiasingSetupConfig::Mode mode);     /*@jsdoc     * Gets the view port resolution scale.     * @function Render.getViewportResolutionScale     * @returns {number} The view port resolution scale, <code>&gt; 0.0</code>.     */    float getViewportResolutionScale() const;     /*@jsdoc     * Sets the view port resolution scale.     * @function Render.setViewportResolutionScale     * @param {number} resolutionScale - The view port resolution scale to set, <code>&gt; 0.0</code>.     */    void setViewportResolutionScale(float resolutionScale);     /*@jsdoc     * Returns the list of screens     * @function Render.getScreens     * @returns {string[]} The names of the available screens.     */    QStringList getScreens() const;     /*@jsdoc     * Gets the screen used when switching to full screen mode.     * @function Render.getFullScreenScreen     * @returns {string} The name of the screen used for full screen mode.     */    QString getFullScreenScreen() const;     /*@jsdoc     * Sets the screen used when switching to full screen mode.     * This function will only succeed if the name passed is one of the entries from Render.getScreens.     * Otherwise, it will return False and have no effect.     *     * @function Render.setFullScreenScreen     * @returns {bool} True if the setting was successful.     */    bool setFullScreenScreen(QString name);     /*@jsdoc     * Gets the vertical field of view in degrees.     * @function Render.getVerticalFieldOfView     * @returns {number} The vertical field of view in degrees.     */    float getVerticalFieldOfView() { return qApp->getFieldOfView(); }     /*@jsdoc     * Sets the vertical field of view in degrees.     * @function Render.setVerticalFieldOfView     * @param {number} fieldOfView - The vertical field of view in degrees to set.     */    void setVerticalFieldOfView(float fieldOfView);     /*@jsdoc     * Gets whether or not third person camera clipping is enabled.     * @function Render.getCameraClippingEnabled     * @returns {boolean} <code>true</code> if camera clipping is enabled, <code>false</code> if it's disabled.     */    bool getCameraClippingEnabled() { return qApp->getCameraClippingEnabled(); }     /*@jsdoc     * Sets whether or not third person camera clipping is enabled.     * @function Render.setCameraClippingEnabled     * @param {boolean} enabled - <code>true</code> to enable third person camera clipping, <code>false</code> to disable.     */    void setCameraClippingEnabled(bool enabled); signals:     /*@jsdoc     * Triggered when one of the <code>Render</code> API's properties changes.     * @function Render.settingsChanged     * @returns {Signal}     * @example <caption>Report when a render setting changes.</caption>     * Render.settingsChanged.connect(function () {     *     print("Render setting changed");     * });     * // Toggle Developer > Render > Shadows or similar to trigger.     */    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 _hazeEnabled { true };    bool _bloomEnabled { true };    bool _ambientOcclusionEnabled { true };    bool _localLightingEnabled { true };    bool _proceduralMaterialsEnabled { true };    AntialiasingSetupConfig::Mode _antialiasingMode { AntialiasingSetupConfig::Mode::NONE };    float _viewportResolutionScale { 1.0f };    QString _fullScreenScreen;     // 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> _hazeEnabledSetting { "hazeEnabled", true };    Setting::Handle<bool> _bloomEnabledSetting { "bloomEnabled", true };    Setting::Handle<bool> _ambientOcclusionEnabledSetting { "ambientOcclusionEnabled", true };    Setting::Handle<bool> _localLightingSetting { "localLightingEnabled", true };    Setting::Handle<bool> _proceduralMaterialsEnabledSetting { "proceduralMaterialsEnabled", true };    Setting::Handle<int> _antialiasingModeSetting { "antialiasingMode", (int)AntialiasingSetupConfig::Mode::NONE };    Setting::Handle<float> _viewportResolutionScaleSetting { "viewportResolutionScale", 1.0f };    Setting::Handle<QString> _fullScreenScreenSetting { "fullScreenScreen", "" };     // Force assign both setting AND runtime value to the parameter value    void forceRenderMethod(RenderMethod renderMethod);    void forceShadowsEnabled(bool enabled);    void forceHazeEnabled(bool enabled);    void forceBloomEnabled(bool enabled);    void forceAmbientOcclusionEnabled(bool enabled);    void forceLocalLightingEnabled(bool enabled);    void forceProceduralMaterialsEnabled(bool enabled);    void forceAntialiasingMode(AntialiasingSetupConfig::Mode mode);    void forceViewportResolutionScale(float scale);     static std::once_flag registry_flag;}; #endif  // hifi_RenderScriptingInterface_h