dali/internal/system/common/environment-options.h

   1 #ifndef DALI_INTERNAL_ADAPTOR_ENVIRONMENT_OPTIONS_H
   2 #define DALI_INTERNAL_ADAPTOR_ENVIRONMENT_OPTIONS_H
   3
   4 /*
   5  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <memory>
  23 #include <dali/integration-api/debug.h>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/integration-api/adaptor-framework/log-factory-interface.h>
  27 #include <dali/internal/adaptor/common/threading-mode.h>
  28
  29 namespace Dali
  30 {
  31 namespace Internal
  32 {
  33 namespace Adaptor
  34 {
  35 class TraceManager;
  36 class PerformanceInterface;
  37
  38 /**
  39  * This class provides the environment options which define settings as well as
  40  * the ability to install a log function.
  41  *
  42  */
  43 class EnvironmentOptions : public Dali::LogFactoryInterface
  44 {
  45 public:
  46
  47   /**
  48    * Constructor
  49    */
  50   EnvironmentOptions();
  51
  52   /**
  53    * Virtual Destructor for interface cleanup
  54    */
  55   virtual ~EnvironmentOptions();
  56
  57   /**
  58    * Create a TraceManager which is used for tracing.
  59    * @param PerformanceInterface for using network logging for tracing on Ubuntu
  60    */
  61   void CreateTraceManager( PerformanceInterface* performanceInterface );
  62
  63   /**
  64    * Initialize TraceManager by installing Trace function.
  65    */
  66   void InstallTraceFunction() const;
  67
  68   /**
  69    * @param logFunction logging function
  70    */
  71   void SetLogFunction( const Dali::Integration::Log::LogFunction& logFunction );
  72
  73   /**
  74    * Install the log function for the current thread.
  75    */
  76   void InstallLogFunction() const override;
  77
  78   /**
  79    * Un-install the log function for the current thread.
  80    */
  81   void UnInstallLogFunction() const;
  82
  83   /**
  84    * @return whether network control is enabled or not ( 0 = off, 1 = on )
  85    */
  86   unsigned int GetNetworkControlMode() const;
  87
  88   /**
  89    * @return frequency of how often FPS is logged out (e.g. 0 = off, 2 = every 2 seconds).
  90    */
  91   unsigned int GetFrameRateLoggingFrequency() const;
  92
  93   /**
  94    * @return frequency of how often Update Status is logged out (e.g. 0 = off, 60 = log every 60 frames = 1 second @ 60FPS).
  95    */
  96   unsigned int GetUpdateStatusLoggingFrequency() const;
  97
  98   /**
  99    * @return object profiler status interval ( 0 == off )
 100    */
 101   unsigned int GetObjectProfilerInterval() const;
 102
 103   /**
 104    * @return performance statistics log level ( 0 == off )
 105    */
 106   unsigned int GetPerformanceStatsLoggingOptions() const;
 107
 108   /**
 109    * @return performance statistics log frequency in seconds
 110    */
 111   unsigned int GetPerformanceStatsLoggingFrequency() const;
 112
 113   /**
 114    * @return performance time stamp output ( 0 == off)
 115    */
 116   unsigned int GetPerformanceTimeStampOutput() const;
 117
 118   /**
 119    * @return pan-gesture logging level ( 0 == off )
 120    */
 121   unsigned int GetPanGestureLoggingLevel() const;
 122
 123   /**
 124    * @return pan-gesture prediction mode ( -1 means not set so no prediction, 0 = no prediction )
 125    */
 126   int GetPanGesturePredictionMode() const;
 127
 128   /**
 129    * @return pan-gesture prediction amount
 130    */
 131   int GetPanGesturePredictionAmount() const;
 132
 133   /**
 134    * @return maximum pan-gesture prediction amount
 135    */
 136   int GetPanGestureMaximumPredictionAmount() const;
 137
 138   /**
 139    * @return minimum pan-gesture prediction amount
 140    */
 141   int GetPanGestureMinimumPredictionAmount() const;
 142
 143   /**
 144    * @brief Gets the prediction amount to adjust when the pan velocity is changed.
 145    *
 146    * If the pan velocity is accelerating, the prediction amount will be increased
 147    * by the specified amount until it reaches the upper bound. If the pan velocity
 148    * is decelerating, the prediction amount will be decreased by the specified
 149    * amount until it reaches the lower bound.
 150    *
 151    * @return pan-gesture prediction amount adjustment
 152    */
 153   int GetPanGesturePredictionAmountAdjustment() const;
 154
 155   /**
 156    * @return pan-gesture smoothing mode ( -1 means not set so no smoothing, 0 = no smoothing )
 157    */
 158   int GetPanGestureSmoothingMode() const;
 159
 160   /**
 161    * @return pan-gesture smoothing amount
 162    */
 163   float GetPanGestureSmoothingAmount() const;
 164
 165   /**
 166    * @return pan-gesture use actual times is true if real gesture and frame times are to be used.
 167    */
 168   int GetPanGestureUseActualTimes() const;
 169
 170   /**
 171    * @return pan-gesture interpolation time range is the time range (ms) of past points to use (with weights) when interpolating.
 172    */
 173   int GetPanGestureInterpolationTimeRange() const;
 174
 175   /**
 176    * @return pan-gesture scalar only prediction, when enabled, ignores acceleration.
 177    */
 178   int GetPanGestureScalarOnlyPredictionEnabled() const;
 179
 180   /**
 181    * @return pan-gesture two point prediction combines two interpolated points to get more steady acceleration and velocity values.
 182    */
 183   int GetPanGestureTwoPointPredictionEnabled() const;
 184
 185   /**
 186    * @return pan-gesture two point interpolate past time is the time delta (ms) in the past to interpolate the second point.
 187    */
 188   int GetPanGestureTwoPointInterpolatePastTime() const;
 189
 190   /**
 191    * @return pan-gesture two point velocity bias is the ratio of first and second points to use for velocity.
 192    * 0.0f = 100% of first point. 1.0f = 100% of second point.
 193    */
 194   float GetPanGestureTwoPointVelocityBias() const;
 195
 196   /**
 197    * @return pan-gesture two point acceleration bias is the ratio of first and second points to use for acceleration.
 198    * 0.0f = 100% of first point. 1.0f = 100% of second point.
 199    */
 200   float GetPanGestureTwoPointAccelerationBias() const;
 201
 202   /**
 203    * @return pan-gesture multitap smoothing range is the range in time (ms) of points in the history to smooth the final output against.
 204    */
 205   int GetPanGestureMultitapSmoothingRange() const;
 206
 207   /**
 208    * @return The minimum distance before a pan can be started (-1 means it's not set)
 209    */
 210   int GetMinimumPanDistance() const;
 211
 212   /**
 213    * @return The minimum events before a pan can be started (-1 means it's not set)
 214    */
 215   int GetMinimumPanEvents() const;
 216
 217   /**
 218    * @return The minimum pixels before a pinch can be started (-1 means it's not set)
 219    */
 220   float GetMinimumPinchDistance() const;
 221
 222   /**
 223    * @return The minimum touch events required before a pinch can be started (-1 means it's not set)
 224    */
 225   int GetMinimumPinchTouchEvents() const;
 226
 227   /**
 228    * @return The minimum touch events required after a pinch started (-1 means it's not set)
 229    */
 230   int GetMinimumPinchTouchEventsAfterStart() const;
 231
 232   /**
 233    * @return The minimum touch events required before a rotation can be started (-1 means it's not set)
 234    */
 235   int GetMinimumRotationTouchEvents() const;
 236
 237   /**
 238    * @return The minimum touch events required after a rotation started (-1 means it's not set)
 239    */
 240   int GetMinimumRotationTouchEventsAfterStart() const;
 241
 242   /**
 243    * @return The minimum holding time required to be recognized as a long press gesture (milliseconds)
 244    */
 245   int GetLongPressMinimumHoldingTime() const;
 246
 247   /**
 248    * @return The width of the window
 249    */
 250   unsigned int GetWindowWidth() const;
 251
 252   /**
 253    * @return The height of the window
 254    */
 255   unsigned int GetWindowHeight() const;
 256
 257   /**
 258    * @brief Get the graphics status time
 259    */
 260   int GetGlesCallTime() const;
 261
 262   /**
 263    * @brief Get whether or not to accumulate gles call statistics
 264    */
 265   bool GetGlesCallAccumulate() const;
 266
 267   /**
 268    * @return true if performance server is required
 269    */
 270   bool PerformanceServerRequired() const;
 271
 272   /**
 273    * @return Gets the window name.
 274    */
 275   const std::string& GetWindowName() const;
 276
 277   /**
 278    * @return Gets the window class.
 279    */
 280   const std::string& GetWindowClassName() const;
 281
 282   /**
 283    * @return The thread mode that DALi should use.
 284    */
 285   ThreadingMode::Type GetThreadingMode() const;
 286
 287   /**
 288    * @return The render refresh rate.
 289    */
 290   unsigned int GetRenderRefreshRate() const;
 291
 292   /**
 293    * @return The number of samples required in multisample buffers
 294    */
 295   int GetMultiSamplingLevel() const;
 296
 297   /**
 298    * @return The maximum texture size
 299    */
 300   unsigned int GetMaxTextureSize() const;
 301
 302   /**
 303    * @brief Retrieves the interval of frames to be rendered into the Frame Buffer Object and the Frame Buffer.
 304    *
 305    * @return The number of frames that are going to be rendered into the Frame Buffer Object but the last one which is going to be rendered into the Frame Buffer.
 306    */
 307   unsigned int GetRenderToFboInterval() const;
 308
 309   /**
 310    * @return Whether the depth buffer is required.
 311    */
 312   bool DepthBufferRequired() const;
 313
 314   /**
 315    * @return Whether the stencil buffer is required.
 316    */
 317   bool StencilBufferRequired() const;
 318
 319   /**
 320    * @return Whether the partial update is required.
 321    */
 322   bool PartialUpdateRequired() const;
 323
 324   /// Deleted copy constructor.
 325   EnvironmentOptions( const EnvironmentOptions& ) = delete;
 326
 327   /// Deleted move constructor.
 328   EnvironmentOptions( const EnvironmentOptions&& ) = delete;
 329
 330   /// Deleted assignment operator.
 331   EnvironmentOptions& operator=( const EnvironmentOptions& ) = delete;
 332
 333   /// Deleted move assignment operator.
 334   EnvironmentOptions& operator=( const EnvironmentOptions&& ) = delete;
 335
 336 private: // Internal
 337
 338   /**
 339    * Parses the environment options.
 340    * Called from the constructor
 341    */
 342   void ParseEnvironmentOptions();
 343
 344 private: // Data
 345
 346   Dali::Integration::Log::LogFunction mLogFunction;
 347   std::string mWindowName;                        ///< name of the window
 348   std::string mWindowClassName;                   ///< name of the class the window belongs to
 349   unsigned int mNetworkControl;                   ///< whether network control is enabled
 350   unsigned int mFpsFrequency;                     ///< how often fps is logged out in seconds
 351   unsigned int mUpdateStatusFrequency;            ///< how often update status is logged out in frames
 352   unsigned int mObjectProfilerInterval;           ///< how often object counts are logged out in seconds
 353   unsigned int mPerformanceStatsLevel;            ///< performance statistics logging bitmask
 354   unsigned int mPerformanceStatsFrequency;        ///< performance statistics logging frequency (seconds)
 355   unsigned int mPerformanceTimeStampOutput;       ///< performance time stamp output ( bitmask)
 356   unsigned int mPanGestureLoggingLevel;           ///< pan-gesture log level
 357   unsigned int mWindowWidth;                      ///< width of the window
 358   unsigned int mWindowHeight;                     ///< height of the window
 359   unsigned int mRenderRefreshRate;                ///< render refresh rate
 360   unsigned int mMaxTextureSize;                   ///< The maximum texture size that GL can handle
 361   unsigned int mRenderToFboInterval;              ///< The number of frames that are going to be rendered into the Frame Buffer Object but the last one which is going to be rendered into the Frame Buffer.
 362   int mPanGesturePredictionMode;                  ///< prediction mode for pan gestures
 363   int mPanGesturePredictionAmount;                ///< prediction amount for pan gestures
 364   int mPanGestureMaxPredictionAmount;             ///< maximum prediction amount for pan gestures
 365   int mPanGestureMinPredictionAmount;             ///< minimum prediction amount for pan gestures
 366   int mPanGesturePredictionAmountAdjustment;      ///< adjustment of prediction amount for pan gestures
 367   int mPanGestureSmoothingMode;                   ///< prediction mode for pan gestures
 368   float mPanGestureSmoothingAmount;               ///< prediction amount for pan gestures
 369   int mPanGestureUseActualTimes;                  ///< Disable to optionally override actual times if they make results worse.
 370   int mPanGestureInterpolationTimeRange;          ///< Time into past history (ms) to use points to interpolate the first point.
 371   int mPanGestureScalarOnlyPredictionEnabled;     ///< If enabled, prediction is done using velocity alone (no integration or acceleration).
 372   int mPanGestureTwoPointPredictionEnabled;       ///< If enabled, a second interpolated point is predicted and combined with the first to get more stable values.
 373   int mPanGestureTwoPointInterpolatePastTime;     ///< The target time in the past to generate the second interpolated point.
 374   float mPanGestureTwoPointVelocityBias;          ///< The ratio of first and second interpolated points to use for velocity. 0.0f = 100% of first point. 1.0f = 100% of second point.
 375   float mPanGestureTwoPointAccelerationBias;      ///< The ratio of first and second interpolated points to use for acceleration. 0.0f = 100% of first point. 1.0f = 100% of second point.
 376   int mPanGestureMultitapSmoothingRange;          ///< The range in time (ms) of points in the history to smooth the final output against.
 377   int mPanMinimumDistance;                        ///< minimum distance required before pan starts
 378   int mPanMinimumEvents;                          ///< minimum events required before pan starts
 379   float mPinchMinimumDistance;                    ///< minimum number of pixels moved before a pinch starts
 380   int mPinchMinimumTouchEvents;                   ///< minimum events required before a pinch starts
 381   int mPinchMinimumTouchEventsAfterStart;         ///< minimum events required after a pinch started
 382   int mRotationMinimumTouchEvents;                ///< minimum events required before a rotation starts
 383   int mRotationMinimumTouchEventsAfterStart;      ///< minimum events required after a rotation started
 384   int mLongPressMinimumHoldingTime;               ///< minimum holding time required to be recognized as a long press gesture (millisecond)
 385   int mGlesCallTime;                              ///< time in seconds between status updates
 386   int mMultiSamplingLevel;                        ///< The number of samples required in multisample buffers
 387   ThreadingMode::Type mThreadingMode;             ///< threading mode
 388   bool mGlesCallAccumulate;                       ///< Whether or not to accumulate gles call statistics
 389   bool mDepthBufferRequired;                      ///< Whether the depth buffer is required
 390   bool mStencilBufferRequired;                    ///< Whether the stencil buffer is required
 391   bool mPartialUpdateRequired;                    ///< Whether the partial update is required
 392   std::unique_ptr<TraceManager> mTraceManager;    ///< TraceManager
 393 };
 394
 395 } // Adaptor
 396 } // Internal
 397 } // Dali
 398
 399 #endif // DALI_INTERNAL_ADAPTOR_ENVIRONMENT_OPTIONS_H