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

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/system/common/environment-options.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/render-controller.h>
  23 #include <dali/public-api/math/math-utils.h>
  24 #include <cstdlib>
  25 #include <functional>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali/internal/system/common/environment-variables.h>
  29 #include <dali/internal/trace/common/trace-factory.h>
  30
  31 namespace Dali
  32 {
  33 namespace Internal
  34 {
  35 namespace Adaptor
  36 {
  37 namespace
  38 {
  39 const unsigned int DEFAULT_STATISTICS_LOG_FREQUENCY        = 2;
  40 const int          DEFAULT_MULTI_SAMPLING_LEVEL            = -1;
  41 const bool         DEFAULT_DEPTH_BUFFER_REQUIRED_SETTING   = true;
  42 const bool         DEFAULT_STENCIL_BUFFER_REQUIRED_SETTING = true;
  43 const bool         DEFAULT_PARTIAL_UPDATE_REQUIRED_SETTING = true;
  44
  45 unsigned int GetEnvironmentVariable(const char* variable, unsigned int defaultValue)
  46 {
  47   const char* variableParameter = std::getenv(variable);
  48
  49   // if the parameter exists convert it to an integer, else return the default value
  50   unsigned int intValue = variableParameter ? std::atoi(variableParameter) : defaultValue;
  51   return intValue;
  52 }
  53
  54 bool GetEnvironmentVariable(const char* variable, int& intValue)
  55 {
  56   const char* variableParameter = std::getenv(variable);
  57
  58   if(!variableParameter)
  59   {
  60     return false;
  61   }
  62   // if the parameter exists convert it to an integer, else return the default value
  63   intValue = std::atoi(variableParameter);
  64   return true;
  65 }
  66
  67 bool GetEnvironmentVariable(const char* variable, float& floatValue)
  68 {
  69   const char* variableParameter = std::getenv(variable);
  70
  71   if(!variableParameter)
  72   {
  73     return false;
  74   }
  75   // if the parameter exists convert it to an integer, else return the default value
  76   floatValue = std::atof(variableParameter);
  77   return true;
  78 }
  79
  80 void SetFromEnvironmentVariable(const char* variable, std::string& stringValue)
  81 {
  82   const char* charValue = std::getenv(variable);
  83   if(charValue)
  84   {
  85     stringValue = charValue;
  86   }
  87 }
  88
  89 template<typename Type>
  90 void SetFromEnvironmentVariable(const char* variable, Type& memberVariable)
  91 {
  92   Type envVarValue = -1;
  93   if(GetEnvironmentVariable(variable, envVarValue))
  94   {
  95     memberVariable = envVarValue;
  96   }
  97 }
  98
  99 template<typename Type>
 100 void SetFromEnvironmentVariable(const char* variable, std::function<void(Type)> function)
 101 {
 102   Type envVarValue = -1;
 103   if(GetEnvironmentVariable(variable, envVarValue))
 104   {
 105     function(envVarValue);
 106   }
 107 }
 108
 109 /// Provides a functor which ensures a non-negative number is set for the given member variable
 110 struct MinimumZero
 111 {
 112   MinimumZero(int& memberValue)
 113   : mMemberValue(memberValue)
 114   {
 115   }
 116
 117   void operator()(int value)
 118   {
 119     // Negative Amounts do not make sense
 120     mMemberValue = std::max(0, value);
 121   }
 122
 123   int& mMemberValue;
 124 };
 125
 126 /// Provides a functor which clamps the environment variable between 0.0f and 1.0f
 127 struct ClampBetweenZeroAndOne
 128 {
 129   ClampBetweenZeroAndOne(float& memberValue)
 130   : mMemberValue(memberValue)
 131   {
 132   }
 133
 134   void operator()(float value)
 135   {
 136     value        = Clamp(value, 0.0f, 1.0f);
 137     mMemberValue = value;
 138   }
 139
 140   float& mMemberValue;
 141 };
 142
 143 /// Provides a functor which only sets the member variable if the environment variable value is greater than the specified constant
 144 struct GreaterThan
 145 {
 146   GreaterThan(unsigned int& memberValue, int greaterThanValue)
 147   : mMemberValue(memberValue),
 148     mGreaterThanValue(greaterThanValue)
 149   {
 150   }
 151
 152   void operator()(int value)
 153   {
 154     if(value > mGreaterThanValue)
 155     {
 156       mMemberValue = value;
 157     }
 158   }
 159
 160   unsigned int& mMemberValue;
 161   const int     mGreaterThanValue;
 162 };
 163
 164 /// Provides a functor which sets the member to 1 if if the environment variable value is not zero
 165 struct EnableIfNonZero
 166 {
 167   EnableIfNonZero(int& memberValue)
 168   : mMemberValue(memberValue)
 169   {
 170   }
 171
 172   void operator()(int value)
 173   {
 174     mMemberValue = (value == 0) ? 0 : 1;
 175   }
 176
 177   int& mMemberValue;
 178 };
 179
 180 /// Provides a functor which sets the member to false if the environment variable value is not zero
 181 struct DisableIfNonZero
 182 {
 183   DisableIfNonZero(bool& memberValue)
 184   : mMemberValue(memberValue)
 185   {
 186   }
 187
 188   void operator()(int value)
 189   {
 190     if(value > 0)
 191     {
 192       mMemberValue = false;
 193     }
 194   }
 195
 196   bool& mMemberValue;
 197 };
 198
 199 } // unnamed namespace
 200
 201 EnvironmentOptions::EnvironmentOptions()
 202 : mLogFunction(NULL),
 203   mWindowName(),
 204   mWindowClassName(),
 205   mNetworkControl(0),
 206   mFpsFrequency(0),
 207   mUpdateStatusFrequency(0),
 208   mObjectProfilerInterval(0),
 209   mMemoryPoolInterval(0),
 210   mPerformanceStatsLevel(0),
 211   mPerformanceStatsFrequency(DEFAULT_STATISTICS_LOG_FREQUENCY),
 212   mPerformanceTimeStampOutput(0),
 213   mPanGestureLoggingLevel(0),
 214   mWindowWidth(0u),
 215   mWindowHeight(0u),
 216   mRenderRefreshRate(1u),
 217   mMaxTextureSize(0),
 218   mRenderToFboInterval(0u),
 219   mPanGesturePredictionMode(-1),
 220   mPanGesturePredictionAmount(-1), ///< only sets value in pan gesture if greater than 0
 221   mPanGestureMaxPredictionAmount(-1),
 222   mPanGestureMinPredictionAmount(-1),
 223   mPanGesturePredictionAmountAdjustment(-1),
 224   mPanGestureSmoothingMode(-1),
 225   mPanGestureSmoothingAmount(-1.0f),
 226   mPanGestureUseActualTimes(-1),
 227   mPanGestureInterpolationTimeRange(-1),
 228   mPanGestureScalarOnlyPredictionEnabled(-1),
 229   mPanGestureTwoPointPredictionEnabled(-1),
 230   mPanGestureTwoPointInterpolatePastTime(-1),
 231   mPanGestureTwoPointVelocityBias(-1.0f),
 232   mPanGestureTwoPointAccelerationBias(-1.0f),
 233   mPanGestureMultitapSmoothingRange(-1),
 234   mPanMinimumDistance(-1),
 235   mPanMinimumEvents(-1),
 236   mPinchMinimumDistance(-1.0f),
 237   mPinchMinimumTouchEvents(-1),
 238   mPinchMinimumTouchEventsAfterStart(-1),
 239   mRotationMinimumTouchEvents(-1),
 240   mRotationMinimumTouchEventsAfterStart(-1),
 241   mLongPressMinimumHoldingTime(-1),
 242   mTapMaximumAllowedTime(-1),
 243   mGlesCallTime(0),
 244   mMultiSamplingLevel(DEFAULT_MULTI_SAMPLING_LEVEL),
 245   mThreadingMode(ThreadingMode::COMBINED_UPDATE_RENDER),
 246   mGlesCallAccumulate(false),
 247   mDepthBufferRequired(DEFAULT_DEPTH_BUFFER_REQUIRED_SETTING),
 248   mStencilBufferRequired(DEFAULT_STENCIL_BUFFER_REQUIRED_SETTING),
 249   mPartialUpdateRequired(DEFAULT_PARTIAL_UPDATE_REQUIRED_SETTING)
 250 {
 251   ParseEnvironmentOptions();
 252 }
 253
 254 EnvironmentOptions::~EnvironmentOptions()
 255 {
 256 }
 257
 258 void EnvironmentOptions::CreateTraceManager(PerformanceInterface* performanceInterface)
 259 {
 260   mTraceManager = TraceManagerFactory::CreateTraceFactory(performanceInterface);
 261 }
 262
 263 void EnvironmentOptions::InstallTraceFunction() const
 264 {
 265   if(mTraceManager)
 266   {
 267     mTraceManager->Initialise();
 268   }
 269 }
 270
 271 void EnvironmentOptions::SetLogFunction(const Dali::Integration::Log::LogFunction& logFunction)
 272 {
 273   mLogFunction = logFunction;
 274 }
 275
 276 void EnvironmentOptions::InstallLogFunction() const
 277 {
 278   Dali::Integration::Log::InstallLogFunction(mLogFunction);
 279 }
 280
 281 void EnvironmentOptions::UnInstallLogFunction() const
 282 {
 283   Dali::Integration::Log::UninstallLogFunction();
 284 }
 285
 286 unsigned int EnvironmentOptions::GetNetworkControlMode() const
 287 {
 288   return mNetworkControl;
 289 }
 290 unsigned int EnvironmentOptions::GetFrameRateLoggingFrequency() const
 291 {
 292   return mFpsFrequency;
 293 }
 294
 295 unsigned int EnvironmentOptions::GetUpdateStatusLoggingFrequency() const
 296 {
 297   return mUpdateStatusFrequency;
 298 }
 299
 300 unsigned int EnvironmentOptions::GetObjectProfilerInterval() const
 301 {
 302   return mObjectProfilerInterval;
 303 }
 304 unsigned int EnvironmentOptions::GetMemoryPoolInterval() const
 305 {
 306   return mMemoryPoolInterval;
 307 }
 308 unsigned int EnvironmentOptions::GetPerformanceStatsLoggingOptions() const
 309 {
 310   return mPerformanceStatsLevel;
 311 }
 312 unsigned int EnvironmentOptions::GetPerformanceStatsLoggingFrequency() const
 313 {
 314   return mPerformanceStatsFrequency;
 315 }
 316 unsigned int EnvironmentOptions::GetPerformanceTimeStampOutput() const
 317 {
 318   return mPerformanceTimeStampOutput;
 319 }
 320
 321 unsigned int EnvironmentOptions::GetPanGestureLoggingLevel() const
 322 {
 323   return mPanGestureLoggingLevel;
 324 }
 325
 326 int EnvironmentOptions::GetPanGesturePredictionMode() const
 327 {
 328   return mPanGesturePredictionMode;
 329 }
 330
 331 int EnvironmentOptions::GetPanGesturePredictionAmount() const
 332 {
 333   return mPanGesturePredictionAmount;
 334 }
 335
 336 int EnvironmentOptions::GetPanGestureMaximumPredictionAmount() const
 337 {
 338   return mPanGestureMaxPredictionAmount;
 339 }
 340
 341 int EnvironmentOptions::GetPanGestureMinimumPredictionAmount() const
 342 {
 343   return mPanGestureMinPredictionAmount;
 344 }
 345
 346 int EnvironmentOptions::GetPanGesturePredictionAmountAdjustment() const
 347 {
 348   return mPanGesturePredictionAmountAdjustment;
 349 }
 350
 351 int EnvironmentOptions::GetPanGestureSmoothingMode() const
 352 {
 353   return mPanGestureSmoothingMode;
 354 }
 355
 356 float EnvironmentOptions::GetPanGestureSmoothingAmount() const
 357 {
 358   return mPanGestureSmoothingAmount;
 359 }
 360
 361 int EnvironmentOptions::GetPanGestureUseActualTimes() const
 362 {
 363   return mPanGestureUseActualTimes;
 364 }
 365
 366 int EnvironmentOptions::GetPanGestureInterpolationTimeRange() const
 367 {
 368   return mPanGestureInterpolationTimeRange;
 369 }
 370
 371 int EnvironmentOptions::GetPanGestureScalarOnlyPredictionEnabled() const
 372 {
 373   return mPanGestureScalarOnlyPredictionEnabled;
 374 }
 375
 376 int EnvironmentOptions::GetPanGestureTwoPointPredictionEnabled() const
 377 {
 378   return mPanGestureTwoPointPredictionEnabled;
 379 }
 380
 381 int EnvironmentOptions::GetPanGestureTwoPointInterpolatePastTime() const
 382 {
 383   return mPanGestureTwoPointInterpolatePastTime;
 384 }
 385
 386 float EnvironmentOptions::GetPanGestureTwoPointVelocityBias() const
 387 {
 388   return mPanGestureTwoPointVelocityBias;
 389 }
 390
 391 float EnvironmentOptions::GetPanGestureTwoPointAccelerationBias() const
 392 {
 393   return mPanGestureTwoPointAccelerationBias;
 394 }
 395
 396 int EnvironmentOptions::GetPanGestureMultitapSmoothingRange() const
 397 {
 398   return mPanGestureMultitapSmoothingRange;
 399 }
 400
 401 int EnvironmentOptions::GetMinimumPanDistance() const
 402 {
 403   return mPanMinimumDistance;
 404 }
 405
 406 int EnvironmentOptions::GetMinimumPanEvents() const
 407 {
 408   return mPanMinimumEvents;
 409 }
 410
 411 float EnvironmentOptions::GetMinimumPinchDistance() const
 412 {
 413   return mPinchMinimumDistance;
 414 }
 415
 416 int EnvironmentOptions::GetMinimumPinchTouchEvents() const
 417 {
 418   return mPinchMinimumTouchEvents;
 419 }
 420
 421 int EnvironmentOptions::GetMinimumPinchTouchEventsAfterStart() const
 422 {
 423   return mPinchMinimumTouchEventsAfterStart;
 424 }
 425
 426 int EnvironmentOptions::GetMinimumRotationTouchEvents() const
 427 {
 428   return mRotationMinimumTouchEvents;
 429 }
 430
 431 int EnvironmentOptions::GetMinimumRotationTouchEventsAfterStart() const
 432 {
 433   return mRotationMinimumTouchEventsAfterStart;
 434 }
 435
 436 int EnvironmentOptions::GetLongPressMinimumHoldingTime() const
 437 {
 438   return mLongPressMinimumHoldingTime;
 439 }
 440
 441 int EnvironmentOptions::GetTapMaximumAllowedTime() const
 442 {
 443   return mTapMaximumAllowedTime;
 444 }
 445
 446 unsigned int EnvironmentOptions::GetWindowWidth() const
 447 {
 448   return mWindowWidth;
 449 }
 450
 451 unsigned int EnvironmentOptions::GetWindowHeight() const
 452 {
 453   return mWindowHeight;
 454 }
 455
 456 int EnvironmentOptions::GetGlesCallTime() const
 457 {
 458   return mGlesCallTime;
 459 }
 460
 461 bool EnvironmentOptions::GetGlesCallAccumulate() const
 462 {
 463   return mGlesCallAccumulate;
 464 }
 465
 466 const std::string& EnvironmentOptions::GetWindowName() const
 467 {
 468   return mWindowName;
 469 }
 470
 471 const std::string& EnvironmentOptions::GetWindowClassName() const
 472 {
 473   return mWindowClassName;
 474 }
 475
 476 ThreadingMode::Type EnvironmentOptions::GetThreadingMode() const
 477 {
 478   return mThreadingMode;
 479 }
 480
 481 unsigned int EnvironmentOptions::GetRenderRefreshRate() const
 482 {
 483   return mRenderRefreshRate;
 484 }
 485
 486 int EnvironmentOptions::GetMultiSamplingLevel() const
 487 {
 488   return mMultiSamplingLevel;
 489 }
 490
 491 unsigned int EnvironmentOptions::GetMaxTextureSize() const
 492 {
 493   return mMaxTextureSize;
 494 }
 495
 496 unsigned int EnvironmentOptions::GetRenderToFboInterval() const
 497 {
 498   return mRenderToFboInterval;
 499 }
 500
 501 bool EnvironmentOptions::PerformanceServerRequired() const
 502 {
 503   return ((GetPerformanceStatsLoggingOptions() > 0) ||
 504           (GetPerformanceTimeStampOutput() > 0) ||
 505           (GetNetworkControlMode() > 0));
 506 }
 507
 508 bool EnvironmentOptions::DepthBufferRequired() const
 509 {
 510   return mDepthBufferRequired;
 511 }
 512
 513 bool EnvironmentOptions::StencilBufferRequired() const
 514 {
 515   return mStencilBufferRequired;
 516 }
 517
 518 bool EnvironmentOptions::PartialUpdateRequired() const
 519 {
 520   return mPartialUpdateRequired;
 521 }
 522
 523 void EnvironmentOptions::ParseEnvironmentOptions()
 524 {
 525   // get logging options
 526   mFpsFrequency               = GetEnvironmentVariable(DALI_ENV_FPS_TRACKING, 0);
 527   mUpdateStatusFrequency      = GetEnvironmentVariable(DALI_ENV_UPDATE_STATUS_INTERVAL, 0);
 528   mObjectProfilerInterval     = GetEnvironmentVariable(DALI_ENV_OBJECT_PROFILER_INTERVAL, 0);
 529   mMemoryPoolInterval         = GetEnvironmentVariable(DALI_ENV_MEMORY_POOL_INTERVAL, 0);
 530   mPerformanceStatsLevel      = GetEnvironmentVariable(DALI_ENV_LOG_PERFORMANCE_STATS, 0);
 531   mPerformanceStatsFrequency  = GetEnvironmentVariable(DALI_ENV_LOG_PERFORMANCE_STATS_FREQUENCY, 0);
 532   mPerformanceTimeStampOutput = GetEnvironmentVariable(DALI_ENV_PERFORMANCE_TIMESTAMP_OUTPUT, 0);
 533   mNetworkControl             = GetEnvironmentVariable(DALI_ENV_NETWORK_CONTROL, 0);
 534   mPanGestureLoggingLevel     = GetEnvironmentVariable(DALI_ENV_LOG_PAN_GESTURE, 0);
 535
 536   SetFromEnvironmentVariable(DALI_ENV_PAN_PREDICTION_MODE, mPanGesturePredictionMode);
 537   SetFromEnvironmentVariable<int>(DALI_ENV_PAN_PREDICTION_AMOUNT, MinimumZero(mPanGesturePredictionAmount));
 538   SetFromEnvironmentVariable<int>(DALI_ENV_PAN_MIN_PREDICTION_AMOUNT, MinimumZero(mPanGestureMinPredictionAmount));
 539   SetFromEnvironmentVariable<int>(DALI_ENV_PAN_MAX_PREDICTION_AMOUNT,
 540                                   [&](int maxPredictionAmount) {
 541                                     if(mPanGestureMinPredictionAmount > -1 && maxPredictionAmount < mPanGestureMinPredictionAmount)
 542                                     {
 543                                       // maximum amount should not be smaller than minimum amount
 544                                       maxPredictionAmount = mPanGestureMinPredictionAmount;
 545                                     }
 546                                     mPanGestureMaxPredictionAmount = maxPredictionAmount;
 547                                   });
 548   SetFromEnvironmentVariable<int>(DALI_ENV_PAN_PREDICTION_AMOUNT_ADJUSTMENT, MinimumZero(mPanGesturePredictionAmountAdjustment));
 549   SetFromEnvironmentVariable(DALI_ENV_PAN_SMOOTHING_MODE, mPanGestureSmoothingMode);
 550   SetFromEnvironmentVariable<float>(DALI_ENV_PAN_SMOOTHING_AMOUNT, ClampBetweenZeroAndOne(mPanGestureSmoothingAmount));
 551   SetFromEnvironmentVariable<int>(DALI_ENV_PAN_USE_ACTUAL_TIMES, EnableIfNonZero(mPanGestureUseActualTimes));
 552   SetFromEnvironmentVariable<int>(DALI_ENV_PAN_INTERPOLATION_TIME_RANGE, MinimumZero(mPanGestureInterpolationTimeRange));
 553   SetFromEnvironmentVariable<int>(DALI_ENV_PAN_SCALAR_ONLY_PREDICTION_ENABLED, EnableIfNonZero(mPanGestureScalarOnlyPredictionEnabled));
 554   SetFromEnvironmentVariable<int>(DALI_ENV_PAN_TWO_POINT_PREDICTION_ENABLED, EnableIfNonZero(mPanGestureTwoPointPredictionEnabled));
 555   SetFromEnvironmentVariable<int>(DALI_ENV_PAN_TWO_POINT_PAST_INTERPOLATE_TIME, MinimumZero(mPanGestureTwoPointInterpolatePastTime));
 556   SetFromEnvironmentVariable<float>(DALI_ENV_PAN_TWO_POINT_VELOCITY_BIAS, ClampBetweenZeroAndOne(mPanGestureTwoPointVelocityBias));
 557   SetFromEnvironmentVariable<float>(DALI_ENV_PAN_TWO_POINT_ACCELERATION_BIAS, ClampBetweenZeroAndOne(mPanGestureTwoPointAccelerationBias));
 558   SetFromEnvironmentVariable<int>(DALI_ENV_PAN_MULTITAP_SMOOTHING_RANGE, MinimumZero(mPanGestureMultitapSmoothingRange));
 559   SetFromEnvironmentVariable(DALI_ENV_PAN_MINIMUM_DISTANCE, mPanMinimumDistance);
 560   SetFromEnvironmentVariable(DALI_ENV_PAN_MINIMUM_EVENTS, mPanMinimumEvents);
 561
 562   SetFromEnvironmentVariable(DALI_ENV_PINCH_MINIMUM_DISTANCE, mPinchMinimumDistance);
 563   SetFromEnvironmentVariable(DALI_ENV_PINCH_MINIMUM_TOUCH_EVENTS, mPinchMinimumTouchEvents);
 564   SetFromEnvironmentVariable(DALI_ENV_PINCH_MINIMUM_TOUCH_EVENTS_AFTER_START, mPinchMinimumTouchEventsAfterStart);
 565
 566   SetFromEnvironmentVariable(DALI_ENV_ROTATION_MINIMUM_TOUCH_EVENTS, mRotationMinimumTouchEvents);
 567   SetFromEnvironmentVariable(DALI_ENV_ROTATION_MINIMUM_TOUCH_EVENTS_AFTER_START, mRotationMinimumTouchEventsAfterStart);
 568
 569   SetFromEnvironmentVariable(DALI_ENV_LONG_PRESS_MINIMUM_HOLDING_TIME, mLongPressMinimumHoldingTime);
 570   SetFromEnvironmentVariable(DALI_ENV_TAP_MAXIMUM_ALLOWED_TIME, mTapMaximumAllowedTime);
 571
 572   SetFromEnvironmentVariable(DALI_GLES_CALL_TIME, mGlesCallTime);
 573   SetFromEnvironmentVariable<int>(DALI_GLES_CALL_ACCUMULATE, [&](int glesCallAccumulate) { mGlesCallAccumulate = glesCallAccumulate != 0; });
 574
 575   int windowWidth(0), windowHeight(0);
 576   if(GetEnvironmentVariable(DALI_WINDOW_WIDTH, windowWidth) && GetEnvironmentVariable(DALI_WINDOW_HEIGHT, windowHeight))
 577   {
 578     mWindowWidth  = windowWidth;
 579     mWindowHeight = windowHeight;
 580   }
 581   SetFromEnvironmentVariable(DALI_WINDOW_NAME, mWindowName);
 582   SetFromEnvironmentVariable(DALI_WINDOW_CLASS_NAME, mWindowClassName);
 583
 584   SetFromEnvironmentVariable<int>(DALI_THREADING_MODE,
 585                                   [&](int threadingMode) {
 586                                     switch(threadingMode)
 587                                     {
 588                                       case ThreadingMode::COMBINED_UPDATE_RENDER:
 589                                       {
 590                                         mThreadingMode = static_cast<ThreadingMode::Type>(threadingMode);
 591                                         break;
 592                                       }
 593                                     }
 594                                   });
 595
 596   SetFromEnvironmentVariable<int>(DALI_REFRESH_RATE, GreaterThan(mRenderRefreshRate, 1));
 597
 598   SetFromEnvironmentVariable(DALI_ENV_MULTI_SAMPLING_LEVEL, mMultiSamplingLevel);
 599
 600   SetFromEnvironmentVariable<int>(DALI_ENV_MAX_TEXTURE_SIZE, GreaterThan(mMaxTextureSize, 0));
 601
 602   mRenderToFboInterval = GetEnvironmentVariable(DALI_RENDER_TO_FBO, 0u);
 603
 604   SetFromEnvironmentVariable<int>(DALI_ENV_DISABLE_DEPTH_BUFFER,
 605                                   [&](int depthBufferRequired) {
 606                                     if(depthBufferRequired > 0)
 607                                     {
 608                                       mDepthBufferRequired   = false;
 609                                       mStencilBufferRequired = false; // Disable stencil buffer as well
 610                                     }
 611                                   });
 612   SetFromEnvironmentVariable<int>(DALI_ENV_DISABLE_STENCIL_BUFFER, DisableIfNonZero(mStencilBufferRequired));
 613
 614   SetFromEnvironmentVariable<int>(DALI_ENV_DISABLE_PARTIAL_UPDATE, DisableIfNonZero(mPartialUpdateRequired));
 615 }
 616
 617 } // namespace Adaptor
 618
 619 } // namespace Internal
 620
 621 } // namespace Dali