BVB Source Codes

CRYENGINE Show TimeOfDay.cpp Source code

Return Download CRYENGINE: download TimeOfDay.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   TimeOfDay.cpp
  5. //  Version:     v1.00
  6. //  Created:     25/10/2005 by Timur.
  7. //  Compilers:   Visual Studio.NET 2003
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #include "StdAfx.h"
  15. #include "TimeOfDay.h"
  16. #include "terrain_water.h"
  17. #include <CryMath/ISplines.h>
  18. #include <CryNetwork/IRemoteCommand.h>
  19. #include <CryGame/IGameFramework.h>
  20. #include <CrySerialization/ClassFactory.h>
  21. #include <CrySerialization/Enum.h>
  22. #include <CrySerialization/IArchiveHost.h>
  23. #include "EnvironmentPreset.h"
  24.  
  25. #define SERIALIZATION_ENUM_DEFAULTNAME(x) SERIALIZATION_ENUM(ITimeOfDay::x, # x, # x)
  26.  
  27. SERIALIZATION_ENUM_BEGIN_NESTED(ITimeOfDay, ETimeOfDayParamID, "ETimeOfDayParamID")
  28. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SUN_COLOR)
  29. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SUN_INTENSITY)
  30. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SUN_SPECULAR_MULTIPLIER)
  31.  
  32. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_FOG_COLOR)
  33. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_FOG_COLOR_MULTIPLIER)
  34. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_HEIGHT)
  35. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_DENSITY)
  36. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_FOG_COLOR2)
  37. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_FOG_COLOR2_MULTIPLIER)
  38. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_HEIGHT2)
  39. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_DENSITY2)
  40. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_HEIGHT_OFFSET)
  41.  
  42. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_FOG_RADIAL_COLOR)
  43. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_FOG_RADIAL_COLOR_MULTIPLIER)
  44. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_RADIAL_SIZE)
  45. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_RADIAL_LOBE)
  46.  
  47. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_FINAL_DENSITY_CLAMP)
  48.  
  49. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_GLOBAL_DENSITY)
  50. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_RAMP_START)
  51. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_RAMP_END)
  52. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_RAMP_INFLUENCE)
  53.  
  54. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_SHADOW_DARKENING)
  55. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_SHADOW_DARKENING_SUN)
  56. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_SHADOW_DARKENING_AMBIENT)
  57. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG_SHADOW_RANGE)
  58.  
  59. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_HEIGHT)
  60. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_DENSITY)
  61. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_HEIGHT2)
  62. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_DENSITY2)
  63. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_GLOBAL_DENSITY)
  64. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_RAMP_START)
  65. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_RAMP_END)
  66. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_COLOR1)
  67. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_ANISOTROPIC1)
  68. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_COLOR2)
  69. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_ANISOTROPIC2)
  70. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_BLEND_FACTOR)
  71. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_BLEND_MODE)
  72. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_COLOR)
  73. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_ANISOTROPIC)
  74. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_RANGE)
  75. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_INSCATTER)
  76. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_EXTINCTION)
  77. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_GLOBAL_FOG_VISIBILITY)
  78. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLFOG2_FINAL_DENSITY_CLAMP)
  79.  
  80. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SKYLIGHT_SUN_INTENSITY)
  81. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SKYLIGHT_SUN_INTENSITY_MULTIPLIER)
  82.  
  83. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SKYLIGHT_KM)
  84. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SKYLIGHT_KR)
  85. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SKYLIGHT_G)
  86.  
  87. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SKYLIGHT_WAVELENGTH_R)
  88. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SKYLIGHT_WAVELENGTH_G)
  89. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SKYLIGHT_WAVELENGTH_B)
  90.  
  91. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_HORIZON_COLOR)
  92. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_HORIZON_COLOR_MULTIPLIER)
  93. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_ZENITH_COLOR)
  94. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_ZENITH_COLOR_MULTIPLIER)
  95. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_ZENITH_SHIFT)
  96.  
  97. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_START_INTENSITY)
  98.  
  99. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_MOON_COLOR)
  100. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_MOON_COLOR_MULTIPLIER)
  101. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_MOON_INNERCORONA_COLOR)
  102. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_MOON_INNERCORONA_COLOR_MULTIPLIER)
  103. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_MOON_INNERCORONA_SCALE)
  104. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR)
  105. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR_MULTIPLIER)
  106. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_NIGHSKY_MOON_OUTERCORONA_SCALE)
  107.  
  108. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_CLOUDSHADING_SUNLIGHT_MULTIPLIER)
  109. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_CLOUDSHADING_SKYLIGHT_MULTIPLIER)
  110. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR)
  111. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_MULTIPLIER)
  112. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_INFLUENCE)
  113.  
  114. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_GLOBAL_DENSITY)
  115. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_HEIGHT)
  116. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_THICKNESS)
  117. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_CLOUD_EDGE_TURBULENCE)
  118. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_CLOUD_EDGE_THRESHOLD)
  119. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_SUN_SINGLE_SCATTERING)
  120. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_SUN_LOW_ORDER_SCATTERING)
  121. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_SUN_LOW_ORDER_SCATTERING_ANISTROPY)
  122. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_SUN_HIGH_ORDER_SCATTERING)
  123. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_SKY_LIGHTING_SCATTERING)
  124. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_GOUND_LIGHTING_SCATTERING)
  125. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_GROUND_LIGHTING_ALBEDO)
  126. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_MULTI_SCATTERING_ATTENUATION)
  127. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_MULTI_SCATTERING_PRESERVATION)
  128. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_POWDER_EFFECT)
  129. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_ABSORPTION)
  130. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_ATMOSPHERIC_ALBEDO)
  131. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_ATMOSPHERIC_SCATTERING)
  132. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_VOLCLOUD_WIND_INFLUENCE)
  133.  
  134. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SUN_SHAFTS_VISIBILITY)
  135. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SUN_RAYS_VISIBILITY)
  136. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SUN_RAYS_ATTENUATION)
  137. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SUN_RAYS_SUNCOLORINFLUENCE)
  138. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SUN_RAYS_CUSTOMCOLOR)
  139.  
  140. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_OCEANFOG_COLOR)
  141. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_OCEANFOG_COLOR_MULTIPLIER)
  142. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_OCEANFOG_DENSITY)
  143.  
  144. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SKYBOX_MULTIPLIER)
  145.  
  146. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_FILMCURVE_SHOULDER_SCALE)
  147. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_FILMCURVE_LINEAR_SCALE)
  148. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_FILMCURVE_TOE_SCALE)
  149. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_FILMCURVE_WHITEPOINT)
  150.  
  151. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_COLORGRADING_COLOR_SATURATION)
  152. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_COLORGRADING_COLOR_BALANCE)
  153.  
  154. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_EYEADAPTATION_SCENEKEY)
  155. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_EYEADAPTATION_MIN_EXPOSURE)
  156. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_EYEADAPTATION_MAX_EXPOSURE)
  157. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_EYEADAPTATION_EV_MIN)
  158. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_EYEADAPTATION_EV_MAX)
  159. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_EYEADAPTATION_EV_AUTO_COMPENSATION)
  160. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_BLOOM_AMOUNT)
  161.  
  162. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_COLORGRADING_FILTERS_GRAIN)
  163. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_COLORGRADING_FILTERS_PHOTOFILTER_COLOR)
  164. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_COLORGRADING_FILTERS_PHOTOFILTER_DENSITY)
  165.  
  166. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_COLORGRADING_DOF_FOCUSRANGE)
  167. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_COLORGRADING_DOF_BLURAMOUNT)
  168.  
  169. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC0_BIAS)
  170. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC0_SLOPE_BIAS)
  171. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC1_BIAS)
  172. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC1_SLOPE_BIAS)
  173. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC2_BIAS)
  174. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC2_SLOPE_BIAS)
  175. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC3_BIAS)
  176. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC3_SLOPE_BIAS)
  177. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC4_BIAS)
  178. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC4_SLOPE_BIAS)
  179. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC5_BIAS)
  180. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC5_SLOPE_BIAS)
  181. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC6_BIAS)
  182. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC6_SLOPE_BIAS)
  183. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC7_BIAS)
  184. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOWSC7_SLOPE_BIAS)
  185.  
  186. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SHADOW_JITTERING)
  187.  
  188. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_HDR_DYNAMIC_POWER_FACTOR)
  189. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_TERRAIN_OCCL_MULTIPLIER)
  190. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_GI_MULTIPLIER)
  191. SERIALIZATION_ENUM_DEFAULTNAME(PARAM_SUN_COLOR_MULTIPLIER)
  192. SERIALIZATION_ENUM_END()
  193. #undef SERIALIZATION_ENUM_DEFAULTNAME
  194.  
  195. SERIALIZATION_ENUM_BEGIN_NESTED(ITimeOfDay, EVariableType, "ETimeOfDayVariableType")
  196. SERIALIZATION_ENUM(ITimeOfDay::TYPE_FLOAT, "TYPE_FLOAT", "TYPE_FLOAT")
  197. SERIALIZATION_ENUM(ITimeOfDay::TYPE_COLOR, "TYPE_COLOR", "TYPE_COLOR")
  198. SERIALIZATION_ENUM_END()
  199.  
  200. //////////////////////////////////////////////////////////////////////////
  201.  
  202. class CBezierSplineFloat : public spline::CSplineKeyInterpolator<spline::BezierKey<float>>
  203. {
  204. public:
  205.         float m_fMinValue;
  206.         float m_fMaxValue;
  207.  
  208.         virtual spline::Formatting GetFormatting() const override
  209.         {
  210.                 return ",::";
  211.         }
  212. };
  213.  
  214. //////////////////////////////////////////////////////////////////////////
  215. class CBezierSplineVec3 : public spline::CSplineKeyInterpolator<spline::BezierKey<Vec3>>
  216. {
  217. public:
  218.  
  219.         void ClampValues(float fMinValue, float fMaxValue)
  220.         {
  221.                 for (int i = 0, nkeys = num_keys(); i < nkeys; i++)
  222.                 {
  223.                         ValueType val;
  224.                         if (GetKeyValue(i, val))
  225.                         {
  226.                                 //val[0] = clamp_tpl(val[0],fMinValue,fMaxValue);
  227.                                 //val[1] = clamp_tpl(val[1],fMinValue,fMaxValue);
  228.                                 //val[2] = clamp_tpl(val[2],fMinValue,fMaxValue);
  229.                                 SetKeyValue(i, val);
  230.                         }
  231.                 }
  232.         }
  233.         virtual spline::Formatting GetFormatting() const override
  234.         {
  235.                 return ",::";
  236.         }
  237. };
  238.  
  239. //////////////////////////////////////////////////////////////////////////
  240.  
  241. namespace
  242. {
  243. // for compatibility with the old ISplines.h format
  244. SBezierControlPoint::ETangentType ESplineKeyTangentTypeToETangentType(ESplineKeyTangentType type)
  245. {
  246.         return SBezierControlPoint::ETangentType(type);
  247. }
  248.  
  249. void ReadCTimeOfDayVariableFromXmlNode(CTimeOfDayVariable* pVar, XmlNodeRef varNode)
  250. {
  251.         CTimeOfDayVariable& var = *pVar;
  252.         XmlNodeRef splineNode = varNode->findChild("Spline");
  253.         if (var.GetType() == ITimeOfDay::TYPE_FLOAT)
  254.         {
  255.                 CBezierSpline* pSpline = var.GetSpline(0);
  256.  
  257.                 CBezierSplineFloat floatSpline;
  258.                 floatSpline.SerializeSpline(splineNode, true);
  259.  
  260.                 ISplineInterpolator::ValueType fValue;
  261.                 const int nKeyCount = floatSpline.GetKeyCount();
  262.                 pSpline->Resize(nKeyCount);
  263.                 for (int k = 0; k < nKeyCount; ++k)
  264.                 {
  265.                         const float fKeyTime = floatSpline.GetKeyTime(k) * CEnvironmentPreset::GetAnimTimeSecondsIn24h();
  266.  
  267.                         ISplineInterpolator::ZeroValue(fValue);
  268.                         floatSpline.GetKeyValue(k, fValue);
  269.  
  270.                         float fTangentsIn[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
  271.                         float fTangentsOut[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
  272.                         floatSpline.GetKeyTangents(k, fTangentsIn, fTangentsOut);
  273.  
  274.                         const int nKeyFlags = floatSpline.GetKeyFlags(k);
  275.                         ESplineKeyTangentType inTangentType = ESplineKeyTangentType((nKeyFlags & SPLINE_KEY_TANGENT_IN_MASK) >> SPLINE_KEY_TANGENT_IN_SHIFT);
  276.                         ESplineKeyTangentType outTangentType = ESplineKeyTangentType((nKeyFlags & SPLINE_KEY_TANGENT_OUT_MASK) >> SPLINE_KEY_TANGENT_OUT_SHIFT);
  277.  
  278.                         SBezierKey& key = pSpline->GetKey(k);
  279.                         key.m_controlPoint.m_value = fValue[0];
  280.                         key.m_time = SAnimTime(fKeyTime);
  281.                         key.m_controlPoint.m_inTangentType = ESplineKeyTangentTypeToETangentType(inTangentType);
  282.                         key.m_controlPoint.m_inTangent = Vec2(fTangentsIn[0], fTangentsIn[1]);
  283.                         key.m_controlPoint.m_outTangentType = ESplineKeyTangentTypeToETangentType(outTangentType);
  284.                         key.m_controlPoint.m_outTangent = Vec2(fTangentsOut[0], fTangentsOut[1]);
  285.                 }   //for k
  286.         }
  287.         else if (var.GetType() == ITimeOfDay::TYPE_COLOR)
  288.         {
  289.                 CBezierSplineVec3 colorSpline;
  290.                 colorSpline.SerializeSpline(splineNode, true);
  291.                 colorSpline.ClampValues(-100, 100);
  292.  
  293.                 ISplineInterpolator::ValueType fValue;
  294.                 const int nKeyCount = colorSpline.GetKeyCount();
  295.  
  296.                 var.GetSpline(0)->Resize(nKeyCount);
  297.                 var.GetSpline(1)->Resize(nKeyCount);
  298.                 var.GetSpline(2)->Resize(nKeyCount);
  299.                 for (int k = 0; k < nKeyCount; ++k)
  300.                 {
  301.                         float fKeyTime = colorSpline.GetKeyTime(k) * CEnvironmentPreset::GetAnimTimeSecondsIn24h();
  302.  
  303.                         ISplineInterpolator::ZeroValue(fValue);
  304.                         colorSpline.GetKeyValue(k, fValue);
  305.  
  306.                         float fTangentsIn[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
  307.                         float fTangentsOut[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
  308.                         colorSpline.GetKeyTangents(k, fTangentsIn, fTangentsOut);
  309.  
  310.                         const int nKeyFlags = colorSpline.GetKeyFlags(k);
  311.                         ESplineKeyTangentType inTangentType = ESplineKeyTangentType((nKeyFlags & SPLINE_KEY_TANGENT_IN_MASK) >> SPLINE_KEY_TANGENT_IN_SHIFT);
  312.                         ESplineKeyTangentType outTangentType = ESplineKeyTangentType((nKeyFlags & SPLINE_KEY_TANGENT_OUT_MASK) >> SPLINE_KEY_TANGENT_OUT_SHIFT);
  313.  
  314.                         SBezierKey key;
  315.                         key.m_time = SAnimTime(fKeyTime);
  316.                         key.m_controlPoint.m_inTangentType = ESplineKeyTangentTypeToETangentType(inTangentType);
  317.                         key.m_controlPoint.m_inTangent = Vec2(fTangentsIn[0], fTangentsIn[1]);
  318.                         key.m_controlPoint.m_outTangentType = ESplineKeyTangentTypeToETangentType(outTangentType);
  319.                         key.m_controlPoint.m_outTangent = Vec2(fTangentsOut[0], fTangentsOut[1]);
  320.  
  321.                         key.m_controlPoint.m_value = fValue[0];
  322.                         var.GetSpline(0)->GetKey(k) = key;
  323.                         key.m_controlPoint.m_value = fValue[1];
  324.                         var.GetSpline(1)->GetKey(k) = key;
  325.                         key.m_controlPoint.m_value = fValue[2];
  326.                         var.GetSpline(2)->GetKey(k) = key;
  327.                 }   //for k
  328.         }
  329. }
  330.  
  331. void ReadPresetFromToDXMLNode(CEnvironmentPreset& pPreset, XmlNodeRef node)
  332. {
  333.         const int nChildCount = node->getChildCount();
  334.         for (int i = 0; i < nChildCount; ++i)
  335.         {
  336.                 XmlNodeRef varNode = node->getChild(i);
  337.                 const char* varName = varNode->getAttr("Name");
  338.                 if (!varName)
  339.                         continue;
  340.  
  341.                 CTimeOfDayVariable* pVar = pPreset.GetVar(varName);
  342.                 if (!pVar)
  343.                         continue;
  344.  
  345.                 ReadCTimeOfDayVariableFromXmlNode(pVar, varNode);
  346.         } // for i
  347. }   //void ReadWeatherPresetFromToDXMLNode
  348.  
  349. void MigrateLegacyData(CEnvironmentPreset& preset, bool bSunIntensity)
  350. {
  351.         if (bSunIntensity)    // Convert sun intensity as specified up to CE 3.8.2 to illuminance
  352.         {
  353.                 CTimeOfDayVariable* varSunIntensity = preset.GetVar(ITimeOfDay::PARAM_SUN_INTENSITY);
  354.                 CTimeOfDayVariable* varSunMult = preset.GetVar(ITimeOfDay::PARAM_SUN_COLOR_MULTIPLIER);
  355.                 CTimeOfDayVariable* varSunColor = preset.GetVar(ITimeOfDay::PARAM_SUN_COLOR);
  356.                 CTimeOfDayVariable* varHDRPower = preset.GetVar(ITimeOfDay::PARAM_HDR_DYNAMIC_POWER_FACTOR);
  357.  
  358.                 CBezierSpline* varSunMultSpline = varSunMult->GetSpline(0);
  359.                 const int numKeys = varSunMultSpline->GetKeyCount();
  360.                 for (int key = 0; key < numKeys; ++key)
  361.                 {
  362.                         SBezierKey& varSunMultKey = varSunMultSpline->GetKey(key);
  363.                         SAnimTime anim_time = varSunMultKey.m_time;
  364.                         float time = anim_time.ToFloat();
  365.                         float sunMult = varSunMultKey.m_controlPoint.m_value;
  366.  
  367.                         float sunColorR = varSunColor->GetSpline(0)->Evaluate(time);
  368.                         float sunColorG = varSunColor->GetSpline(1)->Evaluate(time);
  369.                         float sunColorB = varSunColor->GetSpline(2)->Evaluate(time);
  370.  
  371.                         float hdrPower = varHDRPower->GetSpline(0)->Evaluate(time);
  372.  
  373.                         float hdrMult = powf(HDRDynamicMultiplier, hdrPower);
  374.                         float sunColorLum = sunColorR * 0.2126f + sunColorG * 0.7152f + sunColorB * 0.0722f;
  375.                         float sunIntensity = sunMult * sunColorLum * hdrMult * 10000.0f * gf_PI;
  376.  
  377.                         varSunIntensity->GetSpline(0)->InsertKey(anim_time, sunIntensity);
  378.                 }
  379.         }
  380. }
  381.  
  382. void LoadPresetFromOldFormatXML(CEnvironmentPreset& preset, XmlNodeRef node)
  383. {
  384.         ReadPresetFromToDXMLNode(preset, node);
  385.  
  386.         bool bSunIntensityFound = false;
  387.         const int nChildCount = node->getChildCount();
  388.         for (int i = 0; i < nChildCount; ++i)
  389.         {
  390.                 XmlNodeRef varNode = node->getChild(i);
  391.                 const char* varName = varNode->getAttr("Name");
  392.                 if (!varName)
  393.                         continue;
  394.  
  395.                 if (!strcmp(varName, "Sun intensity"))
  396.                         bSunIntensityFound = true;
  397.  
  398.                 // copy data from old node to new node if old nodes exist.
  399.                 // this needs to maintain compatibility from CE 3.8.2 to above.
  400.                 // this should be removed in the future.
  401.                 if (!strcmp(varName, "Volumetric fog 2: Fog albedo color"))
  402.                 {
  403.                         ReadCTimeOfDayVariableFromXmlNode(preset.GetVar(ITimeOfDay::PARAM_VOLFOG2_COLOR1), varNode);
  404.                         ReadCTimeOfDayVariableFromXmlNode(preset.GetVar(ITimeOfDay::PARAM_VOLFOG2_COLOR2), varNode);
  405.                         ReadCTimeOfDayVariableFromXmlNode(preset.GetVar(ITimeOfDay::PARAM_VOLFOG2_COLOR), varNode);
  406.                 }
  407.                 if (!strcmp(varName, "Volumetric fog 2: Anisotropic factor"))
  408.                 {
  409.                         ReadCTimeOfDayVariableFromXmlNode(preset.GetVar(ITimeOfDay::PARAM_VOLFOG2_ANISOTROPIC1), varNode);
  410.                         ReadCTimeOfDayVariableFromXmlNode(preset.GetVar(ITimeOfDay::PARAM_VOLFOG2_ANISOTROPIC), varNode);
  411.                 }
  412.         }
  413.         MigrateLegacyData(preset, !bSunIntensityFound);
  414. }
  415.  
  416. static const char* sPresetsLibsPath = "libs/environmentpresets/";
  417. static const char* sPresetXMLRootNodeName = "EnvironmentPreset";
  418.  
  419. string GetPresetXMLFilenamefromName(const string& presetName, const bool bForWriting)
  420. {
  421.         //const string filePath = sPresetsLibsPath + presetName + ".xml";
  422.         const string filePath = presetName;
  423.  
  424.         char szAdjustedFile[ICryPak::g_nMaxPath];
  425.         const char* szTemp = gEnv->pCryPak->AdjustFileName(filePath.c_str(), szAdjustedFile, bForWriting ? ICryPak::FLAGS_FOR_WRITING : 0);
  426.         return string(szAdjustedFile);
  427. }
  428.  
  429. bool SavePresetToXML(const CEnvironmentPreset& preset, const string& presetName)
  430. {
  431.         const string filename = GetPresetXMLFilenamefromName(presetName, false);
  432.  
  433.         if (!Serialization::SaveXmlFile(filename.c_str(), preset, sPresetXMLRootNodeName))
  434.         {
  435.                 CryWarning(VALIDATOR_MODULE_3DENGINE, VALIDATOR_ERROR, "TimeOfDay: Failed to save preset: %s", presetName.c_str());
  436.                 return false;
  437.         }
  438.  
  439.         return true;
  440. }
  441.  
  442. bool LoadPresetFromXML(CEnvironmentPreset& pPreset, const string& presetName)
  443. {
  444.         const string filename = GetPresetXMLFilenamefromName(presetName, false);
  445.         const bool bFileExist = gEnv->pCryPak->IsFileExist(filename.c_str());
  446.         if (!bFileExist)
  447.         {
  448.                 CryWarning(VALIDATOR_MODULE_3DENGINE, VALIDATOR_ERROR, "TimeOfDay: Failed to load preset: %s", presetName.c_str());
  449.                 return true;   // return true, so preset stays in list. Sandbox will indicate that no file found
  450.         }
  451.  
  452.         Serialization::LoadXmlFile(pPreset, filename.c_str());
  453.         return true;
  454. }
  455.  
  456. Vec3 ConvertIlluminanceToLightColor(float illuminance, Vec3 colorRGB)
  457. {
  458.         illuminance /= RENDERER_LIGHT_UNIT_SCALE;
  459.  
  460.         ColorF color(colorRGB);
  461.         color.adjust_luminance(illuminance);
  462.  
  463.         // Divide by PI as this is not done in the BRDF at the moment
  464.         Vec3 finalColor = color.toVec3() / gf_PI;
  465.  
  466.         return finalColor;
  467. }
  468. }
  469.  
  470. //////////////////////////////////////////////////////////////////////////
  471. CTimeOfDay::CTimeOfDay()
  472.         : m_timeOfDayRtpcId(INVALID_AUDIO_CONTROL_ID)
  473. {
  474.         m_pTimer = 0;
  475.         SetTimer(gEnv->pTimer);
  476.         m_fTime = 12;
  477.         m_bEditMode = false;
  478.         m_advancedInfo.fAnimSpeed = 0;
  479.         m_advancedInfo.fStartTime = 0;
  480.         m_advancedInfo.fEndTime = 24;
  481.         m_fHDRMultiplier = 1.f;
  482.         m_pTimeOfDaySpeedCVar = gEnv->pConsole->GetCVar("e_TimeOfDaySpeed");
  483.         m_sunRotationLatitude = 0;
  484.         m_sunRotationLongitude = 0;
  485.         m_bPaused = false;
  486.         m_bSunLinkedToTOD = true;
  487.         memset(m_vars, 0, sizeof(SVariableInfo) * ITimeOfDay::PARAM_TOTAL);
  488.  
  489.         // fill local var list so, sandbox can access var list without level being loaded
  490.         CEnvironmentPreset tempPreset;
  491.         for (int i = 0; i < PARAM_TOTAL; ++i)
  492.         {
  493.                 const CTimeOfDayVariable* presetVar = tempPreset.GetVar((ETimeOfDayParamID)i);
  494.                 SVariableInfo& var = m_vars[i];
  495.  
  496.                 var.name = presetVar->GetName();
  497.                 var.displayName = presetVar->GetDisplayName();
  498.                 var.group = presetVar->GetGroupName();
  499.  
  500.                 var.nParamId = i;
  501.                 var.type = presetVar->GetType();
  502.                 var.pInterpolator = NULL;
  503.  
  504.                 Vec3 presetVal = presetVar->GetValue();
  505.                 var.fValue[0] = presetVal.x;
  506.                 const EVariableType varType = presetVar->GetType();
  507.                 if (varType == TYPE_FLOAT)
  508.                 {
  509.                         var.fValue[1] = presetVar->GetMinValue();
  510.                         var.fValue[2] = presetVar->GetMaxValue();
  511.                 }
  512.                 else if (varType == TYPE_COLOR)
  513.                 {
  514.                         var.fValue[1] = presetVal.y;
  515.                         var.fValue[2] = presetVal.z;
  516.                 }
  517.         }
  518.  
  519.         m_pCurrentPreset = NULL;
  520.  
  521.         gEnv->pAudioSystem->GetAudioRtpcId("time_of_day", m_timeOfDayRtpcId);
  522. }
  523.  
  524. //////////////////////////////////////////////////////////////////////////
  525. CTimeOfDay::~CTimeOfDay()
  526. {
  527.         //delete m_pCurrentPreset;
  528. }
  529.  
  530. void CTimeOfDay::SetTimer(ITimer* pTimer)
  531. {
  532.         assert(pTimer);
  533.         m_pTimer = pTimer;
  534.  
  535.         // Update timer for ocean also - Craig
  536.         COcean::SetTimer(pTimer);
  537. }
  538.  
  539. ITimeOfDay::SVariableInfo& CTimeOfDay::GetVar(ETimeOfDayParamID id)
  540. {
  541.         assert(id == m_vars[id].nParamId);
  542.         return(m_vars[id]);
  543. }
  544.  
  545. bool CTimeOfDay::GetPresetsInfos(SPresetInfo* resultArray, unsigned int arraySize) const
  546. {
  547.         if (arraySize < m_presets.size())
  548.                 return false;
  549.  
  550.         size_t i = 0;
  551.         for (TPresetsSet::const_iterator it = m_presets.begin(); it != m_presets.end(); ++it)
  552.         {
  553.                 resultArray[i].m_pName = it->first.c_str();
  554.                 resultArray[i].m_bCurrent = (m_pCurrentPreset == &(it->second));
  555.                 ++i;
  556.         }
  557.  
  558.         return true;
  559. }
  560.  
  561. bool CTimeOfDay::SetCurrentPreset(const char* szPresetName)
  562. {
  563.         TPresetsSet::iterator it = m_presets.find(szPresetName);
  564.         if (it != m_presets.end())
  565.         {
  566.                 CEnvironmentPreset* newPreset = &(it->second);
  567.                 if (m_pCurrentPreset != newPreset)
  568.                 {
  569.                         m_pCurrentPreset = newPreset;
  570.                         Update(true, true);
  571.                 }
  572.                 return true;
  573.         }
  574.         return false;
  575. }
  576.  
  577. bool CTimeOfDay::AddNewPreset(const char* szPresetName)
  578. {
  579.         TPresetsSet::const_iterator it = m_presets.find(szPresetName);
  580.         if (it == m_presets.end())
  581.         {
  582.                 string presetFileName = GetPresetXMLFilenamefromName(szPresetName, true);
  583.  
  584.                 std::pair<TPresetsSet::iterator, bool> insertResult = m_presets.emplace(string(szPresetName), CEnvironmentPreset());
  585.                 if (insertResult.second)
  586.                 {
  587.                         m_pCurrentPreset = &(insertResult.first->second);
  588.                         Update(true, true);
  589.                 }
  590.                 return true;
  591.         }
  592.         return false;
  593. }
  594.  
  595. bool CTimeOfDay::RemovePreset(const char* szPresetName)
  596. {
  597.         TPresetsSet::const_iterator it = m_presets.find(szPresetName);
  598.         if (it != m_presets.end())
  599.         {
  600.                 if (m_pCurrentPreset == &(it->second))
  601.                         m_pCurrentPreset = NULL;
  602.  
  603.                 m_presets.erase(it);
  604.  
  605.                 if (!m_pCurrentPreset && m_presets.size())
  606.                         m_pCurrentPreset = &(m_presets.begin()->second);
  607.  
  608.                 Update(true, true);
  609.         }
  610.         return true;
  611. }
  612.  
  613. bool CTimeOfDay::SavePreset(const char* szPresetName) const
  614. {
  615.         const string sPresetName(szPresetName);
  616.         TPresetsSet::const_iterator it = m_presets.find(sPresetName);
  617.         if (it != m_presets.end())
  618.         {
  619.                 const bool bResult = SavePresetToXML(it->second, sPresetName);
  620.                 return bResult;
  621.         }
  622.         return false;
  623. }
  624.  
  625. bool CTimeOfDay::LoadPreset(const char* szFilePath)
  626. {
  627.         XmlNodeRef root = GetISystem()->LoadXmlFromFile(szFilePath);
  628.         if (root)
  629.         {
  630.                 const string path(szFilePath);
  631.  
  632.                 TPresetsSet::const_iterator it = m_presets.find(path);
  633.                 if (it != m_presets.end())
  634.                         return false;
  635.  
  636.                 std::pair<TPresetsSet::iterator, bool> insertResult = m_presets.emplace(path, CEnvironmentPreset());
  637.                 CEnvironmentPreset& preset = insertResult.first->second;
  638.                 if (root->isTag(sPresetXMLRootNodeName))
  639.                 {
  640.                         Serialization::LoadXmlFile(preset, szFilePath);
  641.                 }
  642.                 else
  643.                 {
  644.                         //try to load old format
  645.                         LoadPresetFromOldFormatXML(preset, root);
  646.                 }
  647.  
  648.                 m_pCurrentPreset = &preset;
  649.                 Update(true, true);
  650.                 return true;
  651.         }
  652.  
  653.         return false;
  654. }
  655.  
  656. void CTimeOfDay::ResetPreset(const char* szPresetName)
  657. {
  658.         TPresetsSet::iterator it = m_presets.find(szPresetName);
  659.         if (it != m_presets.end())
  660.         {
  661.                 it->second.ResetVariables();
  662.                 Update(true, true);
  663.         }
  664. }
  665.  
  666. bool CTimeOfDay::ImportPreset(const char* szPresetName, const char* szFilePath)
  667. {
  668.         TPresetsSet::iterator it = m_presets.find(szPresetName);
  669.         if (it == m_presets.end())
  670.                 return false;
  671.  
  672.         XmlNodeRef root = GetISystem()->LoadXmlFromFile(szFilePath);
  673.         if (!root)
  674.                 return false;
  675.  
  676.         CEnvironmentPreset& preset = it->second;
  677.         if (root->isTag(sPresetXMLRootNodeName))
  678.         {
  679.                 Serialization::LoadXmlFile(preset, szFilePath);
  680.         }
  681.         else
  682.         {
  683.                 LoadPresetFromOldFormatXML(preset, root);
  684.         }
  685.         //preset.SetDirty(true);
  686.         Update(true, true);
  687.  
  688.         return true;
  689. }
  690.  
  691. bool CTimeOfDay::ExportPreset(const char* szPresetName, const char* szFilePath) const
  692. {
  693.         const string sPresetName(szPresetName);
  694.         TPresetsSet::const_iterator it = m_presets.find(sPresetName);
  695.         if (it != m_presets.end())
  696.         {
  697.                 if (!Serialization::SaveXmlFile(szFilePath, it->second, sPresetXMLRootNodeName))
  698.                 {
  699.                         CryWarning(VALIDATOR_MODULE_3DENGINE, VALIDATOR_ERROR, "TimeOfDay: Failed to save preset: %s", szFilePath);
  700.                         return false;
  701.                 }
  702.                 return true;
  703.         }
  704.         return false;
  705. }
  706.  
  707. //////////////////////////////////////////////////////////////////////////
  708. bool CTimeOfDay::GetVariableInfo(int nIndex, SVariableInfo& varInfo)
  709. {
  710.  
  711.         if (nIndex < 0 || nIndex >= (int)ITimeOfDay::PARAM_TOTAL)
  712.                 return false;
  713.  
  714.         varInfo = m_vars[nIndex];
  715.         return true;
  716. }
  717.  
  718. //////////////////////////////////////////////////////////////////////////
  719. void CTimeOfDay::SetVariableValue(int nIndex, float fValue[3])
  720. {
  721.         if (nIndex < 0 || nIndex >= (int)ITimeOfDay::PARAM_TOTAL)
  722.                 return;
  723.  
  724.         m_vars[nIndex].fValue[0] = fValue[0];
  725.         m_vars[nIndex].fValue[1] = fValue[1];
  726.         m_vars[nIndex].fValue[2] = fValue[2];
  727. }
  728. //////////////////////////////////////////////////////////////////////////
  729.  
  730. bool CTimeOfDay::InterpolateVarInRange(int nIndex, float fMin, float fMax, unsigned int nCount, Vec3* resultArray) const
  731. {
  732.         if (nIndex >= 0 && nIndex < ITimeOfDay::PARAM_TOTAL && m_pCurrentPreset)
  733.         {
  734.                 m_pCurrentPreset->InterpolateVarInRange((ITimeOfDay::ETimeOfDayParamID)nIndex, fMin, fMax, nCount, resultArray);
  735.                 return true;
  736.         }
  737.  
  738.         return false;
  739. }
  740.  
  741. uint CTimeOfDay::GetSplineKeysCount(int nIndex, int nSpline) const
  742. {
  743.         if (nIndex >= 0 && nIndex < ITimeOfDay::PARAM_TOTAL && m_pCurrentPreset)
  744.         {
  745.                 CTimeOfDayVariable* pVar = m_pCurrentPreset->GetVar((ITimeOfDay::ETimeOfDayParamID)nIndex);
  746.                 return pVar->GetSplineKeyCount(nSpline);
  747.         }
  748.         return 0;
  749. }
  750.  
  751. bool CTimeOfDay::GetSplineKeysForVar(int nIndex, int nSpline, SBezierKey* keysArray, unsigned int keysArraySize) const
  752. {
  753.         if (nIndex >= 0 && nIndex < ITimeOfDay::PARAM_TOTAL && m_pCurrentPreset)
  754.         {
  755.                 CTimeOfDayVariable* pVar = m_pCurrentPreset->GetVar((ITimeOfDay::ETimeOfDayParamID)nIndex);
  756.                 return pVar->GetSplineKeys(nSpline, keysArray, keysArraySize);
  757.         }
  758.  
  759.         return false;
  760. }
  761.  
  762. bool CTimeOfDay::SetSplineKeysForVar(int nIndex, int nSpline, const SBezierKey* keysArray, unsigned int keysArraySize)
  763. {
  764.         if (nIndex >= 0 && nIndex < ITimeOfDay::PARAM_TOTAL && m_pCurrentPreset)
  765.         {
  766.                 CTimeOfDayVariable* pVar = m_pCurrentPreset->GetVar((ITimeOfDay::ETimeOfDayParamID)nIndex);
  767.                 const bool bResult = pVar->SetSplineKeys(nSpline, keysArray, keysArraySize);
  768.                 return bResult;
  769.         }
  770.         return false;
  771. }
  772.  
  773. bool CTimeOfDay::UpdateSplineKeyForVar(int nIndex, int nSpline, float fTime, float newValue)
  774. {
  775.         if (nIndex >= 0 && nIndex < ITimeOfDay::PARAM_TOTAL && m_pCurrentPreset)
  776.         {
  777.                 CTimeOfDayVariable* pVar = m_pCurrentPreset->GetVar((ITimeOfDay::ETimeOfDayParamID)nIndex);
  778.                 const bool bResult = pVar->UpdateSplineKeyForTime(nSpline, fTime, newValue);
  779.                 return bResult;
  780.         }
  781.         return false;
  782. }
  783.  
  784. float CTimeOfDay::GetAnimTimeSecondsIn24h()
  785. {
  786.         return CEnvironmentPreset::GetAnimTimeSecondsIn24h();
  787. }
  788.  
  789. //////////////////////////////////////////////////////////////////////////
  790. void CTimeOfDay::ResetVariables()
  791. {
  792.         if (!m_pCurrentPreset)
  793.                 return;
  794.  
  795.         m_pCurrentPreset->ResetVariables();
  796.        
  797.         for (int i = 0; i < PARAM_TOTAL; ++i)
  798.         {
  799.                 const CTimeOfDayVariable* presetVar = m_pCurrentPreset->GetVar((ETimeOfDayParamID)i);
  800.                 SVariableInfo& var = m_vars[i];
  801.  
  802.                 var.name = presetVar->GetName();
  803.                 var.displayName = presetVar->GetDisplayName();
  804.                 var.group = presetVar->GetGroupName();
  805.  
  806.                 var.nParamId = i;
  807.                 var.type = presetVar->GetType();
  808.                 var.pInterpolator = NULL;
  809.  
  810.                 Vec3 presetVal = presetVar->GetValue();
  811.                 var.fValue[0] = presetVal.x;
  812.                 const EVariableType varType = presetVar->GetType();
  813.                 if (varType == TYPE_FLOAT)
  814.                 {
  815.                         var.fValue[1] = presetVar->GetMinValue();
  816.                         var.fValue[2] = presetVar->GetMaxValue();
  817.                 }
  818.                 else if (varType == TYPE_COLOR)
  819.                 {
  820.                         var.fValue[1] = presetVal.y;
  821.                         var.fValue[2] = presetVal.z;
  822.                 }
  823.         }
  824. }
  825.  
  826. //////////////////////////////////////////////////////////////////////////
  827. void CTimeOfDay::SetEnvironmentSettings(const SEnvironmentInfo& envInfo)
  828. {
  829.         m_sunRotationLongitude = envInfo.sunRotationLongitude;
  830.         m_sunRotationLatitude = envInfo.sunRotationLatitude;
  831.         m_bSunLinkedToTOD = envInfo.bSunLinkedToTOD;
  832. }
  833.  
  834. //////////////////////////////////////////////////////////////////////////
  835. void CTimeOfDay::SaveInternalState(struct IDataWriteStream& writer)
  836. {
  837.         // current time
  838.         writer.WriteFloat(GetTime());
  839.  
  840.         // TOD data
  841.         string todXML;
  842.         XmlNodeRef xmlNode = GetISystem()->CreateXmlNode("TimeOfDay");
  843.         if (xmlNode)
  844.         {
  845.                 Serialize(xmlNode, false);
  846.                 todXML = xmlNode->getXML().c_str();
  847.         }
  848.         writer.WriteString(todXML);
  849. }
  850.  
  851. void CTimeOfDay::LoadInternalState(struct IDataReadStream& reader)
  852. {
  853.         // Load time data
  854.         const float timeOfDay = reader.ReadFloat();
  855.  
  856.         // Load TOD data
  857.         std::vector<int8> timeOfDatXML;
  858.         reader << timeOfDatXML;
  859.         if (!timeOfDatXML.empty())
  860.         {
  861.                 XmlNodeRef node = gEnv->pSystem->LoadXmlFromBuffer((const char*)&timeOfDatXML[0], timeOfDatXML.size());
  862.                 if (node)
  863.                 {
  864.                         Serialize(node, true);
  865.                         Update(true, true);
  866.                         SetTime(timeOfDay, true);
  867.                 }
  868.         }
  869. }
  870.  
  871. //////////////////////////////////////////////////////////////////////////
  872. // Time of day is specified in hours.
  873. void CTimeOfDay::SetTime(float fHour, bool bForceUpdate)
  874. {
  875.         // set new time
  876.         m_fTime = fHour;
  877.  
  878.         // Change time variable.
  879.         Cry3DEngineBase::GetCVars()->e_TimeOfDay = m_fTime;
  880.  
  881.         Update(true, bForceUpdate);
  882.  
  883.         // Inform audio of this change.
  884.         if (m_timeOfDayRtpcId != INVALID_AUDIO_CONTROL_ID)
  885.         {
  886.                 const bool isMainThread = (gEnv->mMainThreadId == CryGetCurrentThreadId());
  887.                 SAudioRequest request;
  888.                 request.flags = isMainThread ? eAudioRequestFlags_None : eAudioRequestFlags_ThreadSafePush;
  889.                 SAudioObjectRequestData<eAudioObjectRequestType_SetRtpcValue> requestData;
  890.                 requestData.audioRtpcId = m_timeOfDayRtpcId;
  891.                 requestData.value = m_fTime;
  892.                 request.pData = &requestData;
  893.                 gEnv->pAudioSystem->PushRequest(request);
  894.         }
  895.  
  896.         gEnv->pSystem->GetISystemEventDispatcher()->OnSystemEvent(ESYSTEM_EVENT_TIME_OF_DAY_SET, 0, 0);
  897. }
  898.  
  899. //////////////////////////////////////////////////////////////////////////
  900. void CTimeOfDay::SetSunPos(float longitude, float latitude)
  901. {
  902.         m_sunRotationLongitude = longitude;
  903.         m_sunRotationLatitude = latitude;
  904. }
  905.  
  906. //////////////////////////////////////////////////////////////////////////
  907. void CTimeOfDay::Update(bool bInterpolate, bool bForceUpdate)
  908. {
  909.         FUNCTION_PROFILER(gEnv->pSystem, PROFILE_3DENGINE);
  910.  
  911.         if (bInterpolate)
  912.         {
  913.                 // normalized time for interpolation
  914.                 float t = m_fTime / 24.0f;
  915.  
  916.                 if (m_pCurrentPreset)
  917.                 {
  918.                         m_pCurrentPreset->Update(t);
  919.  
  920.                         for (int i = 0; i < PARAM_TOTAL; ++i)
  921.                         {
  922.                                 const CTimeOfDayVariable* pVar = m_pCurrentPreset->GetVar((ETimeOfDayParamID)i);
  923.                                 const Vec3 varValue = pVar->GetValue();
  924.                                 float* pDst = m_vars[i].fValue;
  925.                                 pDst[0] = varValue.x;
  926.                                 if (pVar->GetType() == TYPE_COLOR)
  927.                                 {
  928.                                         pDst[1] = varValue.y;
  929.                                         pDst[2] = varValue.z;
  930.                                 }
  931.                         }
  932.                 }
  933.         }//if(bInterpolate)
  934.  
  935.         // update environment lighting according to new interpolated values
  936.         UpdateEnvLighting(bForceUpdate);
  937. }
  938.  
  939. //////////////////////////////////////////////////////////////////////////
  940. void CTimeOfDay::UpdateEnvLighting(bool forceUpdate)
  941. {
  942.         C3DEngine* p3DEngine((C3DEngine*)gEnv->p3DEngine);
  943.         IRenderer* pRenderer(gEnv->pRenderer);
  944.         const float fRecip255 = 1.0f / 255.0f;
  945.  
  946.         if (pRenderer)
  947.         {
  948.                 bool bHDRModeEnabled = false;
  949.                 pRenderer->EF_Query(EFQ_HDRModeEnabled, bHDRModeEnabled);
  950.                 if (bHDRModeEnabled)
  951.                 {
  952.                         m_fHDRMultiplier = powf(HDRDynamicMultiplier, GetVar(PARAM_HDR_DYNAMIC_POWER_FACTOR).fValue[0]);
  953.  
  954.                         const Vec3 vEyeAdaptationParams(GetVar(PARAM_HDR_EYEADAPTATION_EV_MIN).fValue[0],
  955.                                                         GetVar(PARAM_HDR_EYEADAPTATION_EV_MAX).fValue[0],
  956.                                                         GetVar(PARAM_HDR_EYEADAPTATION_EV_AUTO_COMPENSATION).fValue[0]);
  957.                         p3DEngine->SetGlobalParameter(E3DPARAM_HDR_EYEADAPTATION_PARAMS, vEyeAdaptationParams);
  958.  
  959.                         const Vec3 vEyeAdaptationParamsLegacy(GetVar(PARAM_HDR_EYEADAPTATION_SCENEKEY).fValue[0],
  960.                                                               GetVar(PARAM_HDR_EYEADAPTATION_MIN_EXPOSURE).fValue[0],
  961.                                                               GetVar(PARAM_HDR_EYEADAPTATION_MAX_EXPOSURE).fValue[0]);
  962.                         p3DEngine->SetGlobalParameter(E3DPARAM_HDR_EYEADAPTATION_PARAMS_LEGACY, vEyeAdaptationParamsLegacy);
  963.  
  964.                         float fHDRShoulderScale(GetVar(PARAM_HDR_FILMCURVE_SHOULDER_SCALE).fValue[0]);
  965.                         float fHDRMidtonesScale(GetVar(PARAM_HDR_FILMCURVE_LINEAR_SCALE).fValue[0]);
  966.                         float fHDRToeScale(GetVar(PARAM_HDR_FILMCURVE_TOE_SCALE).fValue[0]);
  967.                         float fHDRWhitePoint(GetVar(PARAM_HDR_FILMCURVE_WHITEPOINT).fValue[0]);
  968.  
  969.                         p3DEngine->SetGlobalParameter(E3DPARAM_HDR_FILMCURVE_SHOULDER_SCALE, Vec3(fHDRShoulderScale, 0, 0));
  970.                         p3DEngine->SetGlobalParameter(E3DPARAM_HDR_FILMCURVE_LINEAR_SCALE, Vec3(fHDRMidtonesScale, 0, 0));
  971.                         p3DEngine->SetGlobalParameter(E3DPARAM_HDR_FILMCURVE_TOE_SCALE, Vec3(fHDRToeScale, 0, 0));
  972.                         p3DEngine->SetGlobalParameter(E3DPARAM_HDR_FILMCURVE_WHITEPOINT, Vec3(fHDRWhitePoint, 0, 0));
  973.  
  974.                         float fHDRBloomAmount(GetVar(PARAM_HDR_BLOOM_AMOUNT).fValue[0]);
  975.                         p3DEngine->SetGlobalParameter(E3DPARAM_HDR_BLOOM_AMOUNT, Vec3(fHDRBloomAmount, 0, 0));
  976.  
  977.                         float fHDRSaturation(GetVar(PARAM_HDR_COLORGRADING_COLOR_SATURATION).fValue[0]);
  978.                         p3DEngine->SetGlobalParameter(E3DPARAM_HDR_COLORGRADING_COLOR_SATURATION, Vec3(fHDRSaturation, 0, 0));
  979.  
  980.                         Vec3 vColorBalance(GetVar(PARAM_HDR_COLORGRADING_COLOR_BALANCE).fValue[0],
  981.                                            GetVar(PARAM_HDR_COLORGRADING_COLOR_BALANCE).fValue[1],
  982.                                            GetVar(PARAM_HDR_COLORGRADING_COLOR_BALANCE).fValue[2]);
  983.                         p3DEngine->SetGlobalParameter(E3DPARAM_HDR_COLORGRADING_COLOR_BALANCE, vColorBalance);
  984.                 }
  985.                 else
  986.                 {
  987.                         m_fHDRMultiplier = 1.f;
  988.                 }
  989.  
  990.                 pRenderer->SetShadowJittering(GetVar(PARAM_SHADOW_JITTERING).fValue[0]);
  991.         }
  992.  
  993.         float skyBrightMultiplier(GetVar(PARAM_TERRAIN_OCCL_MULTIPLIER).fValue[0]);
  994.         float GIMultiplier(GetVar(PARAM_GI_MULTIPLIER).fValue[0]);
  995.         float sunMultiplier(1.0f);
  996.         float sunSpecMultiplier(GetVar(PARAM_SUN_SPECULAR_MULTIPLIER).fValue[0]);
  997.         float fogMultiplier(GetVar(PARAM_FOG_COLOR_MULTIPLIER).fValue[0] * m_fHDRMultiplier);
  998.         float fogMultiplier2(GetVar(PARAM_FOG_COLOR2_MULTIPLIER).fValue[0] * m_fHDRMultiplier);
  999.         float fogMultiplierRadial(GetVar(PARAM_FOG_RADIAL_COLOR_MULTIPLIER).fValue[0] * m_fHDRMultiplier);
  1000.         float nightSkyHorizonMultiplier(GetVar(PARAM_NIGHSKY_HORIZON_COLOR_MULTIPLIER).fValue[0] * m_fHDRMultiplier);
  1001.         float nightSkyZenithMultiplier(GetVar(PARAM_NIGHSKY_ZENITH_COLOR_MULTIPLIER).fValue[0] * m_fHDRMultiplier);
  1002.         float nightSkyMoonMultiplier(GetVar(PARAM_NIGHSKY_MOON_COLOR_MULTIPLIER).fValue[0] * m_fHDRMultiplier);
  1003.         float nightSkyMoonInnerCoronaMultiplier(GetVar(PARAM_NIGHSKY_MOON_INNERCORONA_COLOR_MULTIPLIER).fValue[0] * m_fHDRMultiplier);
  1004.         float nightSkyMoonOuterCoronaMultiplier(GetVar(PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR_MULTIPLIER).fValue[0] * m_fHDRMultiplier);
  1005.  
  1006.         // set sun position
  1007.         Vec3 sunPos;
  1008.  
  1009.         if (m_bSunLinkedToTOD)
  1010.         {
  1011.                 float timeAng(((m_fTime + 12.0f) / 24.0f) * gf_PI * 2.0f);
  1012.                 float sunRot = gf_PI * (-m_sunRotationLatitude) / 180.0f;
  1013.                 float longitude = 0.5f * gf_PI - gf_PI * m_sunRotationLongitude / 180.0f;
  1014.  
  1015.                 Matrix33 a, b, c, m;
  1016.  
  1017.                 a.SetRotationZ(timeAng);
  1018.                 b.SetRotationX(longitude);
  1019.                 c.SetRotationY(sunRot);
  1020.  
  1021.                 m = a * b * c;
  1022.                 sunPos = Vec3(0, 1, 0) * m;
  1023.  
  1024.                 float h = sunPos.z;
  1025.                 sunPos.z = sunPos.y;
  1026.                 sunPos.y = -h;
  1027.         }
  1028.         else // when not linked, it behaves like the moon
  1029.         {
  1030.                 float sunLati(-gf_PI + gf_PI * m_sunRotationLatitude / 180.0f);
  1031.                 float sunLong(0.5f * gf_PI - gf_PI * m_sunRotationLongitude / 180.0f);
  1032.  
  1033.                 float sinLon(sinf(sunLong));
  1034.                 float cosLon(cosf(sunLong));
  1035.                 float sinLat(sinf(sunLati));
  1036.                 float cosLat(cosf(sunLati));
  1037.  
  1038.                 sunPos = Vec3(sinLon * cosLat, sinLon * sinLat, cosLon);
  1039.         }
  1040.  
  1041.         Vec3 sunPosOrig = sunPos;
  1042.  
  1043.         // transition phase for sun/moon lighting
  1044.         assert(p3DEngine->m_dawnStart <= p3DEngine->m_dawnEnd);
  1045.         assert(p3DEngine->m_duskStart <= p3DEngine->m_duskEnd);
  1046.         assert(p3DEngine->m_dawnEnd <= p3DEngine->m_duskStart);
  1047.         float sunIntensityMultiplier(m_fHDRMultiplier);
  1048.         float dayNightIndicator(1.0);
  1049.         if (m_fTime < p3DEngine->m_dawnStart || m_fTime >= p3DEngine->m_duskEnd)
  1050.         {
  1051.                 // night
  1052.                 sunIntensityMultiplier = 0.0;
  1053.                 p3DEngine->GetGlobalParameter(E3DPARAM_NIGHSKY_MOON_DIRECTION, sunPos);
  1054.                 dayNightIndicator = 0.0;
  1055.         }
  1056.         else if (m_fTime < p3DEngine->m_dawnEnd)
  1057.         {
  1058.                 // dawn
  1059.                 assert(p3DEngine->m_dawnStart < p3DEngine->m_dawnEnd);
  1060.                 float b(0.5f * (p3DEngine->m_dawnStart + p3DEngine->m_dawnEnd));
  1061.                 if (m_fTime < b)
  1062.                 {
  1063.                         // fade out moon
  1064.                         sunMultiplier *= (b - m_fTime) / (b - p3DEngine->m_dawnStart);
  1065.                         sunIntensityMultiplier = 0.0;
  1066.                         p3DEngine->GetGlobalParameter(E3DPARAM_NIGHSKY_MOON_DIRECTION, sunPos);
  1067.                 }
  1068.                 else
  1069.                 {
  1070.                         // fade in sun
  1071.                         float t((m_fTime - b) / (p3DEngine->m_dawnEnd - b));
  1072.                         sunMultiplier *= t;
  1073.                         sunIntensityMultiplier = t;
  1074.                 }
  1075.  
  1076.                 dayNightIndicator = (m_fTime - p3DEngine->m_dawnStart) / (p3DEngine->m_dawnEnd - p3DEngine->m_dawnStart);
  1077.         }
  1078.         else if (m_fTime < p3DEngine->m_duskStart)
  1079.         {
  1080.                 // day
  1081.                 dayNightIndicator = 1.0;
  1082.         }
  1083.         else if (m_fTime < p3DEngine->m_duskEnd)
  1084.         {
  1085.                 // dusk
  1086.                 assert(p3DEngine->m_duskStart < p3DEngine->m_duskEnd);
  1087.                 float b(0.5f * (p3DEngine->m_duskStart + p3DEngine->m_duskEnd));
  1088.                 if (m_fTime < b)
  1089.                 {
  1090.                         // fade out sun
  1091.                         float t((b - m_fTime) / (b - p3DEngine->m_duskStart));
  1092.                         sunMultiplier *= t;
  1093.                         sunIntensityMultiplier = t;
  1094.                 }
  1095.                 else
  1096.                 {
  1097.                         // fade in moon
  1098.                         sunMultiplier *= (m_fTime - b) / (p3DEngine->m_duskEnd - b);
  1099.                         sunIntensityMultiplier = 0.0;
  1100.                         p3DEngine->GetGlobalParameter(E3DPARAM_NIGHSKY_MOON_DIRECTION, sunPos);
  1101.                 }
  1102.  
  1103.                 dayNightIndicator = (p3DEngine->m_duskEnd - m_fTime) / (p3DEngine->m_duskEnd - p3DEngine->m_duskStart);
  1104.         }
  1105.         sunIntensityMultiplier = max(GetVar(PARAM_SKYLIGHT_SUN_INTENSITY_MULTIPLIER).fValue[0], 0.0f);
  1106.         p3DEngine->SetGlobalParameter(E3DPARAM_DAY_NIGHT_INDICATOR, Vec3(dayNightIndicator, 0, 0));
  1107.  
  1108.         p3DEngine->SetSunDir(sunPos);
  1109.  
  1110.         // set sun, sky, and fog color
  1111.         Vec3 sunColor(Vec3(GetVar(PARAM_SUN_COLOR).fValue[0],
  1112.                            GetVar(PARAM_SUN_COLOR).fValue[1], GetVar(PARAM_SUN_COLOR).fValue[2]));
  1113.         float sunIntensityLux(GetVar(PARAM_SUN_INTENSITY).fValue[0] * sunMultiplier);
  1114.         p3DEngine->SetSunColor(ConvertIlluminanceToLightColor(sunIntensityLux, sunColor));
  1115.         p3DEngine->SetGlobalParameter(E3DPARAM_SUN_SPECULAR_MULTIPLIER, Vec3(sunSpecMultiplier, 0, 0));
  1116.         p3DEngine->SetSkyBrightness(skyBrightMultiplier);
  1117.         p3DEngine->SetGIAmount(GIMultiplier);
  1118.  
  1119.         Vec3 fogColor(fogMultiplier * Vec3(GetVar(PARAM_FOG_COLOR).fValue[0],
  1120.                                            GetVar(PARAM_FOG_COLOR).fValue[1], GetVar(PARAM_FOG_COLOR).fValue[2]));
  1121.         p3DEngine->SetFogColor(fogColor);
  1122.  
  1123.         const Vec3 fogColor2 = fogMultiplier2 * Vec3(GetVar(PARAM_FOG_COLOR2).fValue[0], GetVar(PARAM_FOG_COLOR2).fValue[1], GetVar(PARAM_FOG_COLOR2).fValue[2]);
  1124.         p3DEngine->SetGlobalParameter(E3DPARAM_FOG_COLOR2, fogColor2);
  1125.  
  1126.         const Vec3 fogColorRadial = fogMultiplierRadial * Vec3(GetVar(PARAM_FOG_RADIAL_COLOR).fValue[0], GetVar(PARAM_FOG_RADIAL_COLOR).fValue[1], GetVar(PARAM_FOG_RADIAL_COLOR).fValue[2]);
  1127.         p3DEngine->SetGlobalParameter(E3DPARAM_FOG_RADIAL_COLOR, fogColorRadial);
  1128.  
  1129.         const Vec3 volFogHeightDensity = Vec3(GetVar(PARAM_VOLFOG_HEIGHT).fValue[0], GetVar(PARAM_VOLFOG_DENSITY).fValue[0], 0);
  1130.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG_HEIGHT_DENSITY, volFogHeightDensity);
  1131.  
  1132.         const Vec3 volFogHeightDensity2 = Vec3(GetVar(PARAM_VOLFOG_HEIGHT2).fValue[0], GetVar(PARAM_VOLFOG_DENSITY2).fValue[0], 0);
  1133.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG_HEIGHT_DENSITY2, volFogHeightDensity2);
  1134.  
  1135.         const Vec3 volFogGradientCtrl = Vec3(GetVar(PARAM_VOLFOG_HEIGHT_OFFSET).fValue[0], GetVar(PARAM_VOLFOG_RADIAL_SIZE).fValue[0], GetVar(PARAM_VOLFOG_RADIAL_LOBE).fValue[0]);
  1136.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG_GRADIENT_CTRL, volFogGradientCtrl);
  1137.  
  1138.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG_GLOBAL_DENSITY, Vec3(GetVar(PARAM_VOLFOG_GLOBAL_DENSITY).fValue[0], 0, GetVar(PARAM_VOLFOG_FINAL_DENSITY_CLAMP).fValue[0]));
  1139.  
  1140.         // set volumetric fog ramp
  1141.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG_RAMP, Vec3(GetVar(PARAM_VOLFOG_RAMP_START).fValue[0], GetVar(PARAM_VOLFOG_RAMP_END).fValue[0], GetVar(PARAM_VOLFOG_RAMP_INFLUENCE).fValue[0]));
  1142.  
  1143.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG_SHADOW_RANGE, Vec3(GetVar(PARAM_VOLFOG_SHADOW_RANGE).fValue[0], 0, 0));
  1144.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG_SHADOW_DARKENING, Vec3(GetVar(PARAM_VOLFOG_SHADOW_DARKENING).fValue[0], GetVar(PARAM_VOLFOG_SHADOW_DARKENING_SUN).fValue[0], GetVar(PARAM_VOLFOG_SHADOW_DARKENING_AMBIENT).fValue[0]));
  1145.  
  1146.         // set HDR sky lighting properties
  1147.         Vec3 sunIntensity(sunIntensityMultiplier * Vec3(GetVar(PARAM_SKYLIGHT_SUN_INTENSITY).fValue[0],
  1148.                                                         GetVar(PARAM_SKYLIGHT_SUN_INTENSITY).fValue[1], GetVar(PARAM_SKYLIGHT_SUN_INTENSITY).fValue[2]));
  1149.  
  1150.         Vec3 rgbWaveLengths(GetVar(PARAM_SKYLIGHT_WAVELENGTH_R).fValue[0],
  1151.                             GetVar(PARAM_SKYLIGHT_WAVELENGTH_G).fValue[0], GetVar(PARAM_SKYLIGHT_WAVELENGTH_B).fValue[0]);
  1152.  
  1153.         p3DEngine->SetSkyLightParameters(sunPosOrig, sunIntensity, GetVar(PARAM_SKYLIGHT_KM).fValue[0],
  1154.                                          GetVar(PARAM_SKYLIGHT_KR).fValue[0], GetVar(PARAM_SKYLIGHT_G).fValue[0], rgbWaveLengths, forceUpdate);
  1155.  
  1156.         // set night sky color properties
  1157.         Vec3 nightSkyHorizonColor(nightSkyHorizonMultiplier * Vec3(GetVar(PARAM_NIGHSKY_HORIZON_COLOR).fValue[0],
  1158.                                                                    GetVar(PARAM_NIGHSKY_HORIZON_COLOR).fValue[1], GetVar(PARAM_NIGHSKY_HORIZON_COLOR).fValue[2]));
  1159.         p3DEngine->SetGlobalParameter(E3DPARAM_NIGHSKY_HORIZON_COLOR, nightSkyHorizonColor);
  1160.  
  1161.         Vec3 nightSkyZenithColor(nightSkyZenithMultiplier * Vec3(GetVar(PARAM_NIGHSKY_ZENITH_COLOR).fValue[0],
  1162.                                                                  GetVar(PARAM_NIGHSKY_ZENITH_COLOR).fValue[1], GetVar(PARAM_NIGHSKY_ZENITH_COLOR).fValue[2]));
  1163.         p3DEngine->SetGlobalParameter(E3DPARAM_NIGHSKY_ZENITH_COLOR, nightSkyZenithColor);
  1164.  
  1165.         float nightSkyZenithColorShift(GetVar(PARAM_NIGHSKY_ZENITH_SHIFT).fValue[0]);
  1166.         p3DEngine->SetGlobalParameter(E3DPARAM_NIGHSKY_ZENITH_SHIFT, Vec3(nightSkyZenithColorShift, 0, 0));
  1167.  
  1168.         float nightSkyStarIntensity(GetVar(PARAM_NIGHSKY_START_INTENSITY).fValue[0]);
  1169.         p3DEngine->SetGlobalParameter(E3DPARAM_NIGHSKY_STAR_INTENSITY, Vec3(nightSkyStarIntensity, 0, 0));
  1170.  
  1171.         Vec3 nightSkyMoonColor(nightSkyMoonMultiplier * Vec3(GetVar(PARAM_NIGHSKY_MOON_COLOR).fValue[0],
  1172.                                                              GetVar(PARAM_NIGHSKY_MOON_COLOR).fValue[1], GetVar(PARAM_NIGHSKY_MOON_COLOR).fValue[2]));
  1173.         p3DEngine->SetGlobalParameter(E3DPARAM_NIGHSKY_MOON_COLOR, nightSkyMoonColor);
  1174.  
  1175.         Vec3 nightSkyMoonInnerCoronaColor(nightSkyMoonInnerCoronaMultiplier * Vec3(GetVar(PARAM_NIGHSKY_MOON_INNERCORONA_COLOR).fValue[0],
  1176.                                                                                    GetVar(PARAM_NIGHSKY_MOON_INNERCORONA_COLOR).fValue[1], GetVar(PARAM_NIGHSKY_MOON_INNERCORONA_COLOR).fValue[2]));
  1177.         p3DEngine->SetGlobalParameter(E3DPARAM_NIGHSKY_MOON_INNERCORONA_COLOR, nightSkyMoonInnerCoronaColor);
  1178.  
  1179.         float nightSkyMoonInnerCoronaScale(GetVar(PARAM_NIGHSKY_MOON_INNERCORONA_SCALE).fValue[0]);
  1180.         p3DEngine->SetGlobalParameter(E3DPARAM_NIGHSKY_MOON_INNERCORONA_SCALE, Vec3(nightSkyMoonInnerCoronaScale, 0, 0));
  1181.  
  1182.         Vec3 nightSkyMoonOuterCoronaColor(nightSkyMoonOuterCoronaMultiplier * Vec3(GetVar(PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR).fValue[0],
  1183.                                                                                    GetVar(PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR).fValue[1], GetVar(PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR).fValue[2]));
  1184.         p3DEngine->SetGlobalParameter(E3DPARAM_NIGHSKY_MOON_OUTERCORONA_COLOR, nightSkyMoonOuterCoronaColor);
  1185.  
  1186.         float nightSkyMoonOuterCoronaScale(GetVar(PARAM_NIGHSKY_MOON_OUTERCORONA_SCALE).fValue[0]);
  1187.         p3DEngine->SetGlobalParameter(E3DPARAM_NIGHSKY_MOON_OUTERCORONA_SCALE, Vec3(nightSkyMoonOuterCoronaScale, 0, 0));
  1188.  
  1189.         // set sun shafts visibility and activate if required
  1190.  
  1191.         float fSunShaftsVis = GetVar(PARAM_SUN_SHAFTS_VISIBILITY).fValue[0];
  1192.         fSunShaftsVis = clamp_tpl<float>(fSunShaftsVis, 0.0f, 0.3f);
  1193.         float fSunRaysVis = GetVar(PARAM_SUN_RAYS_VISIBILITY).fValue[0];
  1194.         float fSunRaysAtten = GetVar(PARAM_SUN_RAYS_ATTENUATION).fValue[0];
  1195.         float fSunRaySunColInfluence = GetVar(PARAM_SUN_RAYS_SUNCOLORINFLUENCE).fValue[0];
  1196.  
  1197.         float* pSunRaysCustomColorVar = GetVar(PARAM_SUN_RAYS_CUSTOMCOLOR).fValue;
  1198.         Vec4 pSunRaysCustomColor = Vec4(pSunRaysCustomColorVar[0], pSunRaysCustomColorVar[1], pSunRaysCustomColorVar[2], 1.0f);
  1199.  
  1200.         p3DEngine->SetPostEffectParam("SunShafts_Active", (fSunShaftsVis > 0.05f || fSunRaysVis > 0.05f) ? 1.f : 0.f);
  1201.         p3DEngine->SetPostEffectParam("SunShafts_Amount", fSunShaftsVis);
  1202.         p3DEngine->SetPostEffectParam("SunShafts_RaysAmount", fSunRaysVis);
  1203.         p3DEngine->SetPostEffectParam("SunShafts_RaysAttenuation", fSunRaysAtten);
  1204.         p3DEngine->SetPostEffectParam("SunShafts_RaysSunColInfluence", fSunRaySunColInfluence);
  1205.         p3DEngine->SetPostEffectParamVec4("SunShafts_RaysCustomColor", pSunRaysCustomColor);
  1206.  
  1207.         {
  1208.                 const Vec3 cloudShadingMultipliers = Vec3(GetVar(PARAM_CLOUDSHADING_SUNLIGHT_MULTIPLIER).fValue[0], GetVar(PARAM_CLOUDSHADING_SKYLIGHT_MULTIPLIER).fValue[0], 0);
  1209.                 p3DEngine->SetGlobalParameter(E3DPARAM_CLOUDSHADING_MULTIPLIERS, cloudShadingMultipliers);
  1210.  
  1211.                 const float cloudShadingCustomSunColorMult = GetVar(PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_MULTIPLIER).fValue[0];
  1212.                 const Vec3 cloudShadingCustomSunColor = cloudShadingCustomSunColorMult * Vec3(GetVar(PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR).fValue[0], GetVar(PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR).fValue[1], GetVar(PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR).fValue[2]);
  1213.                 const float cloudShadingCustomSunColorInfluence = GetVar(PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_INFLUENCE).fValue[0];
  1214.  
  1215.                 const Vec3 cloudShadingSunColor = p3DEngine->GetSunColor() * cloudShadingMultipliers.x;
  1216.                 const Vec3 cloudShadingSkyColor = p3DEngine->GetSunColor() * cloudShadingMultipliers.y;
  1217.  
  1218.                 p3DEngine->SetGlobalParameter(E3DPARAM_CLOUDSHADING_SUNCOLOR, cloudShadingSunColor + (cloudShadingCustomSunColor - cloudShadingSunColor) * cloudShadingCustomSunColorInfluence);
  1219.  
  1220.                 // set volumetric cloud parameters
  1221.                 const Vec3 volCloudAtmosAlbedo = Vec3(GetVar(PARAM_VOLCLOUD_ATMOSPHERIC_ALBEDO).fValue[0], GetVar(PARAM_VOLCLOUD_ATMOSPHERIC_ALBEDO).fValue[1], GetVar(PARAM_VOLCLOUD_ATMOSPHERIC_ALBEDO).fValue[2]);
  1222.                 const float volCloudRayleighBlue = 2.06e-5f; // Rayleigh scattering coefficient for blue as 488 nm wave length.
  1223.                 const Vec3 volCloudRayleighScattering = volCloudAtmosAlbedo * volCloudRayleighBlue;
  1224.                 p3DEngine->SetGlobalParameter(E3DPARAM_VOLCLOUD_ATMOSPHERIC_SCATTERING, volCloudRayleighScattering);
  1225.  
  1226.                 const Vec3 volCloudGenParam = Vec3(GetVar(PARAM_VOLCLOUD_GLOBAL_DENSITY).fValue[0], GetVar(PARAM_VOLCLOUD_HEIGHT).fValue[0], GetVar(PARAM_VOLCLOUD_THICKNESS).fValue[0]);
  1227.                 p3DEngine->SetGlobalParameter(E3DPARAM_VOLCLOUD_GEN_PARAMS, volCloudGenParam);
  1228.  
  1229.                 const Vec3 volCloudScatteringLow = Vec3(GetVar(PARAM_VOLCLOUD_SUN_SINGLE_SCATTERING).fValue[0], GetVar(PARAM_VOLCLOUD_SUN_LOW_ORDER_SCATTERING).fValue[0], GetVar(PARAM_VOLCLOUD_SUN_LOW_ORDER_SCATTERING_ANISTROPY).fValue[0]);
  1230.                 p3DEngine->SetGlobalParameter(E3DPARAM_VOLCLOUD_SCATTERING_LOW, volCloudScatteringLow);
  1231.  
  1232.                 const Vec3 volCloudScatteringHigh = Vec3(GetVar(PARAM_VOLCLOUD_SUN_HIGH_ORDER_SCATTERING).fValue[0], GetVar(PARAM_VOLCLOUD_SKY_LIGHTING_SCATTERING).fValue[0], GetVar(PARAM_VOLCLOUD_GOUND_LIGHTING_SCATTERING).fValue[0]);
  1233.                 p3DEngine->SetGlobalParameter(E3DPARAM_VOLCLOUD_SCATTERING_HIGH, volCloudScatteringHigh);
  1234.  
  1235.                 const Vec3 volCloudGroundColor = Vec3(GetVar(PARAM_VOLCLOUD_GROUND_LIGHTING_ALBEDO).fValue[0], GetVar(PARAM_VOLCLOUD_GROUND_LIGHTING_ALBEDO).fValue[1], GetVar(PARAM_VOLCLOUD_GROUND_LIGHTING_ALBEDO).fValue[2]);
  1236.                 p3DEngine->SetGlobalParameter(E3DPARAM_VOLCLOUD_GROUND_COLOR, volCloudGroundColor);
  1237.  
  1238.                 const Vec3 volCloudScatteringMulti = Vec3(GetVar(PARAM_VOLCLOUD_MULTI_SCATTERING_ATTENUATION).fValue[0], GetVar(PARAM_VOLCLOUD_MULTI_SCATTERING_PRESERVATION).fValue[0], GetVar(PARAM_VOLCLOUD_POWDER_EFFECT).fValue[0]);
  1239.                 p3DEngine->SetGlobalParameter(E3DPARAM_VOLCLOUD_SCATTERING_MULTI, volCloudScatteringMulti);
  1240.  
  1241.                 const float sunIntensityOriginal = (sunIntensityLux / RENDERER_LIGHT_UNIT_SCALE) / gf_PI; // divided by pi to match to GetSunColor(), it's also divided by pi in ConvertIlluminanceToLightColor().
  1242.                 const float sunIntensityCustomSun = cloudShadingMultipliers.x * cloudShadingCustomSunColorMult;
  1243.                 const float sunIntensityCloudAtmosphere = Lerp(sunIntensityOriginal, sunIntensityCustomSun, cloudShadingCustomSunColorInfluence);
  1244.                 const float atmosphericScatteringMultiplier = GetVar(PARAM_VOLCLOUD_ATMOSPHERIC_SCATTERING).fValue[0];
  1245.                 const Vec3 volCloudWindAtmos = Vec3(GetVar(PARAM_VOLCLOUD_WIND_INFLUENCE).fValue[0], 0.0f, sunIntensityCloudAtmosphere * atmosphericScatteringMultiplier);
  1246.                 p3DEngine->SetGlobalParameter(E3DPARAM_VOLCLOUD_WIND_ATMOSPHERIC, volCloudWindAtmos);
  1247.  
  1248.                 const Vec3 volCloudTurbulence = Vec3(GetVar(PARAM_VOLCLOUD_CLOUD_EDGE_TURBULENCE).fValue[0], GetVar(PARAM_VOLCLOUD_CLOUD_EDGE_THRESHOLD).fValue[0], GetVar(PARAM_VOLCLOUD_ABSORPTION).fValue[0]);
  1249.                 p3DEngine->SetGlobalParameter(E3DPARAM_VOLCLOUD_TURBULENCE, volCloudTurbulence);
  1250.         }
  1251.  
  1252.         // set ocean fog color multiplier
  1253.         const float oceanFogColorMultiplier = GetVar(PARAM_OCEANFOG_COLOR_MULTIPLIER).fValue[0];
  1254.         const Vec3 oceanFogColor = Vec3(GetVar(PARAM_OCEANFOG_COLOR).fValue[0], GetVar(PARAM_OCEANFOG_COLOR).fValue[1], GetVar(PARAM_OCEANFOG_COLOR).fValue[2]);
  1255.         p3DEngine->SetGlobalParameter(E3DPARAM_OCEANFOG_COLOR, oceanFogColor * oceanFogColorMultiplier);
  1256.  
  1257.         const float oceanFogColorDensity = GetVar(PARAM_OCEANFOG_DENSITY).fValue[0];
  1258.         p3DEngine->SetGlobalParameter(E3DPARAM_OCEANFOG_DENSITY, Vec3(oceanFogColorDensity, 0, 0));
  1259.  
  1260.         // set skybox multiplier
  1261.         float skyBoxMulitplier(GetVar(PARAM_SKYBOX_MULTIPLIER).fValue[0] * m_fHDRMultiplier);
  1262.         p3DEngine->SetGlobalParameter(E3DPARAM_SKYBOX_MULTIPLIER, Vec3(skyBoxMulitplier, 0, 0));
  1263.  
  1264.         // Set color grading stuff
  1265.         float fValue = GetVar(PARAM_COLORGRADING_FILTERS_GRAIN).fValue[0];
  1266.         p3DEngine->SetGlobalParameter(E3DPARAM_COLORGRADING_FILTERS_GRAIN, Vec3(fValue, 0, 0));
  1267.  
  1268.         Vec4 pColor = Vec4(GetVar(PARAM_COLORGRADING_FILTERS_PHOTOFILTER_COLOR).fValue[0],
  1269.                            GetVar(PARAM_COLORGRADING_FILTERS_PHOTOFILTER_COLOR).fValue[1],
  1270.                            GetVar(PARAM_COLORGRADING_FILTERS_PHOTOFILTER_COLOR).fValue[2], 1.0f);
  1271.         p3DEngine->SetGlobalParameter(E3DPARAM_COLORGRADING_FILTERS_PHOTOFILTER_COLOR, Vec3(pColor.x, pColor.y, pColor.z));
  1272.         fValue = GetVar(PARAM_COLORGRADING_FILTERS_PHOTOFILTER_DENSITY).fValue[0];
  1273.         p3DEngine->SetGlobalParameter(E3DPARAM_COLORGRADING_FILTERS_PHOTOFILTER_DENSITY, Vec3(fValue, 0, 0));
  1274.  
  1275.         fValue = GetVar(PARAM_COLORGRADING_DOF_FOCUSRANGE).fValue[0];
  1276.         p3DEngine->SetPostEffectParam("Dof_Tod_FocusRange", fValue);
  1277.  
  1278.         fValue = GetVar(PARAM_COLORGRADING_DOF_BLURAMOUNT).fValue[0];
  1279.         p3DEngine->SetPostEffectParam("Dof_Tod_BlurAmount", fValue);
  1280.  
  1281.         const float arrDepthConstBias[MAX_SHADOW_CASCADES_NUM] =
  1282.         {
  1283.                 GetVar(PARAM_SHADOWSC0_BIAS).fValue[0], GetVar(PARAM_SHADOWSC1_BIAS).fValue[0], GetVar(PARAM_SHADOWSC2_BIAS).fValue[0], GetVar(PARAM_SHADOWSC3_BIAS).fValue[0],
  1284.                 GetVar(PARAM_SHADOWSC4_BIAS).fValue[0], GetVar(PARAM_SHADOWSC5_BIAS).fValue[0], GetVar(PARAM_SHADOWSC6_BIAS).fValue[0], GetVar(PARAM_SHADOWSC7_BIAS).fValue[0],
  1285.                 2.0f,                                   2.0f,                                   2.0f,                                   2.0f,
  1286.                 2.0f,                                   2.0f,                                   2.0f,                                   2.0f,
  1287.                 2.0f,                                   2.0f,                                   2.0f,                                   2.0f
  1288.         };
  1289.  
  1290.         const float arrDepthSlopeBias[MAX_SHADOW_CASCADES_NUM] =
  1291.         {
  1292.                 GetVar(PARAM_SHADOWSC0_SLOPE_BIAS).fValue[0], GetVar(PARAM_SHADOWSC1_SLOPE_BIAS).fValue[0], GetVar(PARAM_SHADOWSC2_SLOPE_BIAS).fValue[0], GetVar(PARAM_SHADOWSC3_SLOPE_BIAS).fValue[0],
  1293.                 GetVar(PARAM_SHADOWSC4_SLOPE_BIAS).fValue[0], GetVar(PARAM_SHADOWSC5_SLOPE_BIAS).fValue[0], GetVar(PARAM_SHADOWSC6_SLOPE_BIAS).fValue[0], GetVar(PARAM_SHADOWSC7_SLOPE_BIAS).fValue[0],
  1294.                 0.5f,                                         0.5f,                                         0.5f,                                         0.5f,
  1295.                 0.5f,                                         0.5f,                                         0.5f,                                         0.5f,
  1296.                 0.5f,                                         0.5f,                                         0.5f,                                         0.5f
  1297.         };
  1298.  
  1299.         p3DEngine->SetShadowsCascadesBias(arrDepthConstBias, arrDepthSlopeBias);
  1300.  
  1301.         if (gEnv->IsEditing())
  1302.         {
  1303.                 p3DEngine->SetRecomputeCachedShadows();
  1304.         }
  1305.  
  1306.         // set volumetric fog 2 params
  1307.         const Vec3 volFogCtrlParams = Vec3(GetVar(PARAM_VOLFOG2_RANGE).fValue[0], GetVar(PARAM_VOLFOG2_BLEND_FACTOR).fValue[0], GetVar(PARAM_VOLFOG2_BLEND_MODE).fValue[0]);
  1308.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG2_CTRL_PARAMS, volFogCtrlParams);
  1309.  
  1310.         const Vec3 volFogScatteringParams = Vec3(GetVar(PARAM_VOLFOG2_INSCATTER).fValue[0], GetVar(PARAM_VOLFOG2_EXTINCTION).fValue[0], GetVar(PARAM_VOLFOG2_ANISOTROPIC).fValue[0]);
  1311.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG2_SCATTERING_PARAMS, volFogScatteringParams);
  1312.  
  1313.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG2_RAMP, Vec3(GetVar(PARAM_VOLFOG2_RAMP_START).fValue[0], GetVar(PARAM_VOLFOG2_RAMP_END).fValue[0], 0.0f));
  1314.  
  1315.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG2_COLOR, Vec3(GetVar(PARAM_VOLFOG2_COLOR).fValue[0], GetVar(PARAM_VOLFOG2_COLOR).fValue[1], GetVar(PARAM_VOLFOG2_COLOR).fValue[2]));
  1316.  
  1317.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG2_GLOBAL_DENSITY, Vec3(GetVar(PARAM_VOLFOG2_GLOBAL_DENSITY).fValue[0], GetVar(PARAM_VOLFOG2_FINAL_DENSITY_CLAMP).fValue[0], GetVar(PARAM_VOLFOG2_GLOBAL_FOG_VISIBILITY).fValue[0]));
  1318.  
  1319.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG2_HEIGHT_DENSITY, Vec3(GetVar(PARAM_VOLFOG2_HEIGHT).fValue[0], GetVar(PARAM_VOLFOG2_DENSITY).fValue[0], GetVar(PARAM_VOLFOG2_ANISOTROPIC1).fValue[0]));
  1320.  
  1321.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG2_HEIGHT_DENSITY2, Vec3(GetVar(PARAM_VOLFOG2_HEIGHT2).fValue[0], GetVar(PARAM_VOLFOG2_DENSITY2).fValue[0], GetVar(PARAM_VOLFOG2_ANISOTROPIC2).fValue[0]));
  1322.  
  1323.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG2_COLOR1, Vec3(GetVar(PARAM_VOLFOG2_COLOR1).fValue[0], GetVar(PARAM_VOLFOG2_COLOR1).fValue[1], GetVar(PARAM_VOLFOG2_COLOR1).fValue[2]));
  1324.  
  1325.         p3DEngine->SetGlobalParameter(E3DPARAM_VOLFOG2_COLOR2, Vec3(GetVar(PARAM_VOLFOG2_COLOR2).fValue[0], GetVar(PARAM_VOLFOG2_COLOR2).fValue[1], GetVar(PARAM_VOLFOG2_COLOR2).fValue[2]));
  1326. }
  1327.  
  1328. //////////////////////////////////////////////////////////////////////////
  1329. void CTimeOfDay::SetAdvancedInfo(const SAdvancedInfo& advInfo)
  1330. {
  1331.         m_advancedInfo = advInfo;
  1332.         if (m_pTimeOfDaySpeedCVar->GetFVal() != m_advancedInfo.fAnimSpeed)
  1333.                 m_pTimeOfDaySpeedCVar->Set(m_advancedInfo.fAnimSpeed);
  1334. }
  1335.  
  1336. //////////////////////////////////////////////////////////////////////////
  1337. void CTimeOfDay::GetAdvancedInfo(SAdvancedInfo& advInfo)
  1338. {
  1339.         advInfo = m_advancedInfo;
  1340. }
  1341.  
  1342. //////////////////////////////////////////////////////////////////////////
  1343. void CTimeOfDay::Serialize(XmlNodeRef& node, bool bLoading)
  1344. {
  1345.         if (bLoading)
  1346.         {
  1347.                 node->getAttr("Time", m_fTime);
  1348.  
  1349.                 node->getAttr("TimeStart", m_advancedInfo.fStartTime);
  1350.                 node->getAttr("TimeEnd", m_advancedInfo.fEndTime);
  1351.                 node->getAttr("TimeAnimSpeed", m_advancedInfo.fAnimSpeed);
  1352.  
  1353.                 if (m_pTimeOfDaySpeedCVar->GetFVal() != m_advancedInfo.fAnimSpeed)
  1354.                         m_pTimeOfDaySpeedCVar->Set(m_advancedInfo.fAnimSpeed);
  1355.  
  1356.                 m_pCurrentPreset = NULL;
  1357.                 m_presets.clear();
  1358.                 if (XmlNodeRef presetsNode = node->findChild("Presets"))
  1359.                 {
  1360.                         const int nPresetsCount = presetsNode->getChildCount();
  1361.                         for (int i = 0; i < nPresetsCount; ++i)
  1362.                         {
  1363.                                 if (XmlNodeRef presetNode = presetsNode->getChild(i))
  1364.                                 {
  1365.                                         const char* presetName = presetNode->getAttr("Name");
  1366.                                         if (presetName)
  1367.                                         {
  1368.                                                 string name = presetName;
  1369.                                                 if (!strchr(presetName, '/'))
  1370.                                                 {
  1371.                                                         name = string(sPresetsLibsPath) + name + ".xml"; // temporary for backwards compatibility
  1372.                                                 }
  1373.  
  1374.                                                 std::pair<TPresetsSet::iterator, bool> insertResult = m_presets.emplace(std::make_pair(name, CEnvironmentPreset()));
  1375.                                                 const TPresetsSet::key_type& presetName = insertResult.first->first;
  1376.                                                 CEnvironmentPreset& preset = insertResult.first->second;
  1377.  
  1378.                                                 if (LoadPresetFromXML(preset, name))
  1379.                                                 {
  1380.                                                         if (presetNode->haveAttr("Default"))
  1381.                                                                 m_pCurrentPreset = &preset;
  1382.                                                 }
  1383.                                                 else
  1384.                                                 {
  1385.                                                         m_presets.erase(insertResult.first);
  1386.                                                 }
  1387.                                         }
  1388.                                 }
  1389.                         }
  1390.  
  1391.                 }
  1392.                 else
  1393.                 {
  1394.                         // old format - convert to the new one
  1395.                         string presetName("default");
  1396.                         if (gEnv->pGameFramework)
  1397.                         {
  1398.                                 const char* pLevelName = gEnv->pGameFramework->GetLevelName();
  1399.                                 if (pLevelName && *pLevelName)
  1400.                                 {
  1401.                                         //presetName = pLevelName;
  1402.                                         presetName = string(sPresetsLibsPath) + pLevelName + ".xml";
  1403.                                 }
  1404.                         }
  1405.  
  1406.                         std::pair<TPresetsSet::iterator, bool> insertRes = m_presets.emplace(presetName, CEnvironmentPreset());
  1407.                         CEnvironmentPreset& preset = insertRes.first->second;
  1408.  
  1409.                         LoadPresetFromOldFormatXML(preset, node);
  1410.                 }
  1411.  
  1412.                 if (!m_pCurrentPreset && m_presets.size())
  1413.                         m_pCurrentPreset = &(m_presets.begin()->second);
  1414.  
  1415.                 SetTime(m_fTime, false);
  1416.         }
  1417.         else //if (bLoading)
  1418.         {
  1419.                 node->setAttr("Time", m_fTime);
  1420.                 node->setAttr("TimeStart", m_advancedInfo.fStartTime);
  1421.                 node->setAttr("TimeEnd", m_advancedInfo.fEndTime);
  1422.                 node->setAttr("TimeAnimSpeed", m_advancedInfo.fAnimSpeed);
  1423.                 if (XmlNodeRef presetsNode = node->newChild("Presets"))
  1424.                 {
  1425.                         for (TPresetsSet::const_iterator it = m_presets.begin(); it != m_presets.end(); ++it)
  1426.                         {
  1427.                                 const TPresetsSet::key_type& presetName = it->first;
  1428.                                 const CEnvironmentPreset& preset = it->second;
  1429.                                 if (XmlNodeRef presetNode = presetsNode->newChild("Preset"))
  1430.                                 {
  1431.                                         presetNode->setAttr("Name", presetName.c_str());
  1432.                                         if (&preset == m_pCurrentPreset)
  1433.                                                 presetNode->setAttr("Default", 1);
  1434.                                 }
  1435.                                 SavePresetToXML(preset, presetName);
  1436.                         }
  1437.                 }
  1438.         }
  1439. }
  1440.  
  1441. //////////////////////////////////////////////////////////////////////////
  1442. void CTimeOfDay::Serialize(TSerialize ser)
  1443. {
  1444.         assert(ser.GetSerializationTarget() != eST_Network);
  1445.  
  1446.         string tempName;
  1447.  
  1448.         ser.Value("time", m_fTime);
  1449.         ser.Value("mode", m_bEditMode);
  1450.         ser.Value("m_sunRotationLatitude", m_sunRotationLatitude);
  1451.         ser.Value("m_sunRotationLongitude", m_sunRotationLongitude);
  1452.         const int size = GetVariableCount();
  1453.         ser.BeginGroup("VariableValues");
  1454.         for (int v = 0; v < size; v++)
  1455.         {
  1456.                 tempName = m_vars[v].name;
  1457.                 tempName.replace(' ', '_');
  1458.                 tempName.replace('(', '_');
  1459.                 tempName.replace(')', '_');
  1460.                 tempName.replace(':', '_');
  1461.                 ser.BeginGroup(tempName);
  1462.                 ser.Value("Val0", m_vars[v].fValue[0]);
  1463.                 ser.Value("Val1", m_vars[v].fValue[1]);
  1464.                 ser.Value("Val2", m_vars[v].fValue[2]);
  1465.                 ser.EndGroup();
  1466.         }
  1467.         ser.EndGroup();
  1468.  
  1469.         ser.Value("AdvInfoSpeed", m_advancedInfo.fAnimSpeed);
  1470.         ser.Value("AdvInfoStart", m_advancedInfo.fStartTime);
  1471.         ser.Value("AdvInfoEnd", m_advancedInfo.fEndTime);
  1472.  
  1473.         if (ser.IsReading())
  1474.         {
  1475.                 SetTime(m_fTime, true);
  1476.         }
  1477. }
  1478.  
  1479. //////////////////////////////////////////////////////////////////////////
  1480. void CTimeOfDay::NetSerialize(TSerialize ser, float lag, uint32 flags)
  1481. {
  1482.         if (0 == (flags & NETSER_STATICPROPS))
  1483.         {
  1484.                 if (ser.IsWriting())
  1485.                 {
  1486.                         ser.Value("time", m_fTime, 'tod');
  1487.                 }
  1488.                 else
  1489.                 {
  1490.                         float serializedTime;
  1491.                         ser.Value("time", serializedTime, 'tod');
  1492.                         float remoteTime = serializedTime + ((flags & NETSER_COMPENSATELAG) != 0) * m_advancedInfo.fAnimSpeed * lag;
  1493.                         float setTime = remoteTime;
  1494.                         if (0 == (flags & NETSER_FORCESET))
  1495.                         {
  1496.                                 const float adjustmentFactor = 0.05f;
  1497.                                 const float wraparoundGuardHours = 2.0f;
  1498.  
  1499.                                 float localTime = m_fTime;
  1500.                                 // handle wraparound
  1501.                                 if (localTime < wraparoundGuardHours && remoteTime > (24.0f - wraparoundGuardHours))
  1502.                                         localTime += 24.0f;
  1503.                                 else if (remoteTime < wraparoundGuardHours && localTime > (24.0f - wraparoundGuardHours))
  1504.                                         remoteTime += 24.0f;
  1505.                                 // don't blend times if they're very different
  1506.                                 if (fabsf(remoteTime - localTime) < 1.0f)
  1507.                                 {
  1508.                                         setTime = adjustmentFactor * remoteTime + (1.0f - adjustmentFactor) * m_fTime;
  1509.                                         if (setTime > 24.0f)
  1510.                                                 setTime -= 24.0f;
  1511.                                 }
  1512.                         }
  1513.                         SetTime(setTime, (flags & NETSER_FORCESET) != 0);
  1514.                 }
  1515.         }
  1516.         else
  1517.         {
  1518.                 // no static serialization (yet)
  1519.         }
  1520. }
  1521.  
  1522. //////////////////////////////////////////////////////////////////////////
  1523. void CTimeOfDay::Tick()
  1524. {
  1525.         //      if(!gEnv->bServer)
  1526.         //              return;
  1527.         if (!m_bEditMode && !m_bPaused)
  1528.         {
  1529.                 if (fabs(m_advancedInfo.fAnimSpeed) > 0.0001f)
  1530.                 {
  1531.                         // advance (forward or backward)
  1532.                         float fTime = m_fTime + m_advancedInfo.fAnimSpeed * m_pTimer->GetFrameTime();
  1533.  
  1534.                         // full cycle mode
  1535.                         if (m_advancedInfo.fStartTime <= 0.05f && m_advancedInfo.fEndTime >= 23.5f)
  1536.                         {
  1537.                                 if (fTime > m_advancedInfo.fEndTime)
  1538.                                         fTime = m_advancedInfo.fStartTime;
  1539.                                 if (fTime < m_advancedInfo.fStartTime)
  1540.                                         fTime = m_advancedInfo.fEndTime;
  1541.                         }
  1542.                         else if (fabs(m_advancedInfo.fStartTime - m_advancedInfo.fEndTime) <= 0.05f)//full cycle mode
  1543.                         {
  1544.                                 if (fTime > 24.0f)
  1545.                                         fTime -= 24.0f;
  1546.                                 else if (fTime < 0.0f)
  1547.                                         fTime += 24.0f;
  1548.                         }
  1549.                         else
  1550.                         {
  1551.                                 // clamp advancing time
  1552.                                 if (fTime > m_advancedInfo.fEndTime)
  1553.                                         fTime = m_advancedInfo.fEndTime;
  1554.                                 if (fTime < m_advancedInfo.fStartTime)
  1555.                                         fTime = m_advancedInfo.fStartTime;
  1556.                         }
  1557.  
  1558.                         SetTime(fTime);
  1559.                 }
  1560.         }
  1561. }
  1562.  
downloadTimeOfDay.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top