X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=adaptors%2Fbase%2Fenvironment-options.h;h=af045937dd250f8175ab1fed306b8fac3afa74b8;hb=3576318977e39ac22cd30ae82e9f3b52fe255b7f;hp=625cb06eb8b8fcb25c37a63c42f5db9ac0efa3f9;hpb=c07e3ed89c64a853b2c4a6865c757764761413b1;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/adaptors/base/environment-options.h b/adaptors/base/environment-options.h index 625cb06..af04593 100644 --- a/adaptors/base/environment-options.h +++ b/adaptors/base/environment-options.h @@ -1,8 +1,8 @@ -#ifndef __DALI_INTERNAL_ADAPTOR_ENVIRONMENT_OPTIONS_H__ -#define __DALI_INTERNAL_ADAPTOR_ENVIRONMENT_OPTIONS_H__ +#ifndef DALI_INTERNAL_ADAPTOR_ENVIRONMENT_OPTIONS_H +#define DALI_INTERNAL_ADAPTOR_ENVIRONMENT_OPTIONS_H /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2017 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,8 +18,13 @@ * */ +// EXTERNAL INCLUDES #include +// INTERNAL INCLUDES +#include +#include + namespace Dali { namespace Internal @@ -28,11 +33,12 @@ namespace Adaptor { /** - * Contains environment options which define settings and the ability to install a log function. + * This class provides the environment options which define settings as well as + * the ability to install a log function. + * */ -class EnvironmentOptions +class EnvironmentOptions : public Dali::LogFactoryInterface { - public: /** @@ -41,28 +47,19 @@ public: EnvironmentOptions(); /** - * non-virtual destructor, not intended as a base class + * Virtual Destructor for interface cleanup */ - ~EnvironmentOptions(); + virtual ~EnvironmentOptions(); /** * @param logFunction logging function - * @param logFilterOptions bitmask of the logging options defined in intergration/debug.h (e.g. - * @param logFrameRateFrequency frequency of how often FPS is logged out (e.g. 0 = off, 2 = every 2 seconds). - * @param logupdateStatusFrequency frequency of how often the update status is logged in number of frames - * @param logPerformanceLevel performance logging, 0 = disabled, 1+ = enabled - * @param logPanGestureLevel pan-gesture logging, 0 = disabled, 1 = enabled */ - void SetLogOptions( const Dali::Integration::Log::LogFunction& logFunction, - unsigned int logFrameRateFrequency, - unsigned int logupdateStatusFrequency, - unsigned int logPerformanceLevel, - unsigned int logPanGestureLevel ); + void SetLogFunction( const Dali::Integration::Log::LogFunction& logFunction ); /** * Install the log function for the current thread. */ - void InstallLogFunction() const; + virtual void InstallLogFunction() const; /** * Un-install the log function for the current thread. @@ -70,6 +67,11 @@ public: void UnInstallLogFunction() const; /** + * @return whether network control is enabled or not ( 0 = off, 1 = on ) + */ + unsigned int GetNetworkControlMode() const; + + /** * @return frequency of how often FPS is logged out (e.g. 0 = off, 2 = every 2 seconds). */ unsigned int GetFrameRateLoggingFrequency() const; @@ -80,9 +82,24 @@ public: unsigned int GetUpdateStatusLoggingFrequency() const; /** - * @return logPerformanceLevel performance log level ( 0 = off ) + * @return object profiler status interval ( 0 == off ) + */ + unsigned int GetObjectProfilerInterval() const; + + /** + * @return performance statistics log level ( 0 == off ) + */ + unsigned int GetPerformanceStatsLoggingOptions() const; + + /** + * @return performance statistics log frequency in seconds + */ + unsigned int GetPerformanceStatsLoggingFrequency() const; + + /** + * @return performance time stamp output ( 0 == off) */ - unsigned int GetPerformanceLoggingLevel() const; + unsigned int GetPerformanceTimeStampOutput() const; /** * @return pan-gesture logging level ( 0 == off ) @@ -90,37 +107,243 @@ public: unsigned int GetPanGestureLoggingLevel() const; /** - * @return pan-gesture smoothing mode ( 0 == no smoothing ) + * @return pan-gesture prediction mode ( -1 means not set so no prediction, 0 = no prediction ) */ - unsigned int GetPanGestureSmoothingMode() const; + int GetPanGesturePredictionMode() const; /** - * @brief Sets the mode used to smooth pan gesture movement properties calculated on the Update thread + * @return pan-gesture prediction amount + */ + int GetPanGesturePredictionAmount() const; + + /** + * @return maximum pan-gesture prediction amount + */ + int GetPanGestureMaximumPredictionAmount() const; + + /** + * @return minimum pan-gesture prediction amount + */ + int GetPanGestureMinimumPredictionAmount() const; + + /** + * @brief Gets the prediction amount to adjust when the pan velocity is changed. + * + * If the pan velocity is accelerating, the prediction amount will be increased + * by the specified amount until it reaches the upper bound. If the pan velocity + * is decelerating, the prediction amount will be decreased by the specified + * amount until it reaches the lower bound. * - * @param[in] mode The smoothing mode to use + * @return pan-gesture prediction amount adjustment */ - void SetPanGesturePredictionMode(unsigned int mode) { mPanGesturePredictionMode = mode; } + int GetPanGesturePredictionAmountAdjustment() const; -private: + /** + * @return pan-gesture smoothing mode ( -1 means not set so no smoothing, 0 = no smoothing ) + */ + int GetPanGestureSmoothingMode() const; - unsigned int mFpsFrequency; ///< how often fps is logged out in seconds - unsigned int mUpdateStatusFrequency; ///< how often update status is logged out in frames - unsigned int mPerformanceLoggingLevel; ///< performance log level - unsigned int mPanGestureLoggingLevel; ///< pan-gesture log level - unsigned int mPanGesturePredictionMode; ///< prediction mode for pan gestures + /** + * @return pan-gesture smoothing amount + */ + float GetPanGestureSmoothingAmount() const; - Dali::Integration::Log::LogFunction mLogFunction; + /** + * @return pan-gesture use actual times is true if real gesture and frame times are to be used. + */ + int GetPanGestureUseActualTimes() const; + + /** + * @return pan-gesture interpolation time range is the time range (ms) of past points to use (with weights) when interpolating. + */ + int GetPanGestureInterpolationTimeRange() const; + + /** + * @return pan-gesture scalar only prediction, when enabled, ignores acceleration. + */ + int GetPanGestureScalarOnlyPredictionEnabled() const; + + /** + * @return pan-gesture two point prediction combines two interpolated points to get more steady acceleration and velocity values. + */ + int GetPanGestureTwoPointPredictionEnabled() const; + + /** + * @return pan-gesture two point interpolate past time is the time delta (ms) in the past to interpolate the second point. + */ + int GetPanGestureTwoPointInterpolatePastTime() const; + + /** + * @return pan-gesture two point velocity bias is the ratio of first and second points to use for velocity. + * 0.0f = 100% of first point. 1.0f = 100% of second point. + */ + float GetPanGestureTwoPointVelocityBias() const; + + /** + * @return pan-gesture two point acceleration bias is the ratio of first and second points to use for acceleration. + * 0.0f = 100% of first point. 1.0f = 100% of second point. + */ + float GetPanGestureTwoPointAccelerationBias() const; + + /** + * @return pan-gesture multitap smoothing range is the range in time (ms) of points in the history to smooth the final output against. + */ + int GetPanGestureMultitapSmoothingRange() const; + + /** + * @return The minimum distance before a pan can be started (-1 means it's not set) + */ + int GetMinimumPanDistance() const; + + /** + * @return The minimum events before a pan can be started (-1 means it's not set) + */ + int GetMinimumPanEvents() const; + + /** + * @return The width of the window + */ + unsigned int GetWindowWidth() const; + + /** + * @return The height of the window + */ + unsigned int GetWindowHeight() const; + + /** + * @brief Get the graphics status time + */ + int GetGlesCallTime() const; + + /** + * @brief Get whether or not to accumulate gles call statistics + */ + bool GetGlesCallAccumulate() const; + + /** + * @return true if performance server is required + */ + bool PerformanceServerRequired() const; + + /** + * @return Gets the window name. + */ + const std::string& GetWindowName() const; + + /** + * @return Gets the window class. + */ + const std::string& GetWindowClassName() const; + + /** + * @return The thread mode that DALi should use. + */ + ThreadingMode::Type GetThreadingMode() const; + + /** + * @return The render refresh rate. + */ + unsigned int GetRenderRefreshRate() const; + + /** + * @return The number of samples required in multisample buffers + */ + int GetMultiSamplingLevel() const; + + /** + * @return The maximum texture size + */ + unsigned int GetMaxTextureSize() const; + + /** + * @return The maximum texture size + */ + int GetIndicatorVisibleMode() const; + + /** + * @brief Retrieves the interval of frames to be rendered into the Frame Buffer Object and the Frame Buffer. + * + * @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. + */ + unsigned int GetRenderToFboInterval() const; + + /** + * @return Whether the depth buffer is required. + */ + bool DepthBufferRequired() const; - // Undefined copy constructor. - EnvironmentOptions( const EnvironmentOptions& ); + /** + * @return Whether the stencil buffer is required. + */ + bool StencilBufferRequired() const; + + /// Deleted copy constructor. + EnvironmentOptions( const EnvironmentOptions& ) = delete; + + /// Deleted move constructor. + EnvironmentOptions( const EnvironmentOptions&& ) = delete; - // Undefined assignment operator. - EnvironmentOptions& operator=( const EnvironmentOptions& ); + /// Deleted assignment operator. + EnvironmentOptions& operator=( const EnvironmentOptions& ) = delete; + /// Deleted move assignment operator. + EnvironmentOptions& operator=( const EnvironmentOptions&& ) = delete; + +private: // Internal + + /** + * Parses the environment options. + * Called from the constructor + */ + void ParseEnvironmentOptions(); + +private: // Data + + Dali::Integration::Log::LogFunction mLogFunction; + + std::string mWindowName; ///< name of the window + std::string mWindowClassName; ///< name of the class the window belongs to + unsigned int mNetworkControl; ///< whether network control is enabled + unsigned int mFpsFrequency; ///< how often fps is logged out in seconds + unsigned int mUpdateStatusFrequency; ///< how often update status is logged out in frames + unsigned int mObjectProfilerInterval; ///< how often object counts are logged out in seconds + unsigned int mPerformanceStatsLevel; ///< performance statistics logging bitmask + unsigned int mPerformanceStatsFrequency; ///< performance statistics logging frequency (seconds) + unsigned int mPerformanceTimeStampOutput; ///< performance time stamp output ( bitmask) + unsigned int mPanGestureLoggingLevel; ///< pan-gesture log level + unsigned int mWindowWidth; ///< width of the window + unsigned int mWindowHeight; ///< height of the window + unsigned int mRenderRefreshRate; ///< render refresh rate + unsigned int mMaxTextureSize; ///< The maximum texture size that GL can handle + 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. + int mPanGesturePredictionMode; ///< prediction mode for pan gestures + int mPanGesturePredictionAmount; ///< prediction amount for pan gestures + int mPanGestureMaxPredictionAmount; ///< maximum prediction amount for pan gestures + int mPanGestureMinPredictionAmount; ///< minimum prediction amount for pan gestures + int mPanGesturePredictionAmountAdjustment; ///< adjustment of prediction amount for pan gestures + int mPanGestureSmoothingMode; ///< prediction mode for pan gestures + float mPanGestureSmoothingAmount; ///< prediction amount for pan gestures + int mPanGestureUseActualTimes; ///< Disable to optionally override actual times if they make results worse. + int mPanGestureInterpolationTimeRange; ///< Time into past history (ms) to use points to interpolate the first point. + int mPanGestureScalarOnlyPredictionEnabled; ///< If enabled, prediction is done using velocity alone (no integration or acceleration). + int mPanGestureTwoPointPredictionEnabled; ///< If enabled, a second interpolated point is predicted and combined with the first to get more stable values. + int mPanGestureTwoPointInterpolatePastTime; ///< The target time in the past to generate the second interpolated point. + 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. + 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. + int mPanGestureMultitapSmoothingRange; ///< The range in time (ms) of points in the history to smooth the final output against. + int mPanMinimumDistance; ///< minimum distance required before pan starts + int mPanMinimumEvents; ///< minimum events required before pan starts + int mGlesCallTime; ///< time in seconds between status updates + int mMultiSamplingLevel; ///< The number of samples required in multisample buffers + int mIndicatorVisibleMode; ///< Indicator visible mode + ThreadingMode::Type mThreadingMode; ///< threading mode + bool mGlesCallAccumulate; ///< Whether or not to accumulate gles call statistics + bool mDepthBufferRequired; ///< Whether the depth buffer is required + bool mStencilBufferRequired; ///< Whether the stencil buffer is required }; } // Adaptor } // Internal } // Dali -#endif // __DALI_INTERNAL_ADAPTOR_ENVIRONMENT_OPTIONS_H__ +#endif // DALI_INTERNAL_ADAPTOR_ENVIRONMENT_OPTIONS_H