llwaterparammanager.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:9k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /**
  2.  * @file llwaterparammanager.h
  3.  * @brief Implementation for the LLWaterParamManager class.
  4.  *
  5.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2007-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #ifndef LL_WATER_PARAMMANAGER_H
  33. #define LL_WATER_PARAMMANAGER_H
  34. #include <vector>
  35. #include <map>
  36. #include "llwaterparamset.h"
  37. #include "llviewercamera.h"
  38. #include "v4color.h"
  39. const F32 WATER_FOG_LIGHT_CLAMP = 0.3f;
  40. // color control
  41. struct WaterColorControl {
  42. F32 mR, mG, mB, mA, mI; /// the values
  43. std::string mName; /// name to use to dereference params
  44. std::string mSliderName; /// name of the slider in menu
  45. bool mHasSliderName; /// only set slider name for true color types
  46. inline WaterColorControl(F32 red, F32 green, F32 blue, F32 alpha,
  47.  F32 intensity, const std::string& n, const std::string& sliderName = LLStringUtil::null)
  48. : mR(red), mG(green), mB(blue), mA(alpha), mI(intensity), mName(n), mSliderName(sliderName)
  49. {
  50. // if there's a slider name, say we have one
  51. mHasSliderName = false;
  52. if (mSliderName != "") {
  53. mHasSliderName = true;
  54. }
  55. }
  56. inline WaterColorControl & operator = (LLColor4 const & val) 
  57. {
  58. mR = val.mV[0];
  59. mG = val.mV[1];
  60. mB = val.mV[2];
  61. mA = val.mV[3];
  62. return *this;
  63. }
  64. inline operator LLColor4 (void) const
  65. {
  66. return LLColor4(mR, mG, mB, mA);
  67. }
  68. inline WaterColorControl & operator = (LLVector4 const & val) 
  69. {
  70. mR = val.mV[0];
  71. mG = val.mV[1];
  72. mB = val.mV[2];
  73. mA = val.mV[3];
  74. return *this;
  75. }
  76. inline operator LLVector4 (void) const 
  77. {
  78. return LLVector4(mR, mG, mB, mA);
  79. }
  80. inline operator LLVector3 (void) const 
  81. {
  82. return LLVector3(mR, mG, mB);
  83. }
  84. inline void update(LLWaterParamSet & params) const 
  85. {
  86. params.set(mName, mR, mG, mB, mA);
  87. }
  88. };
  89. struct WaterVector3Control 
  90. {
  91. F32 mX;
  92. F32 mY;
  93. F32 mZ;
  94. std::string mName;
  95. // basic constructor
  96. inline WaterVector3Control(F32 valX, F32 valY, F32 valZ, const std::string& n)
  97. : mX(valX), mY(valY), mZ(valZ), mName(n)
  98. {
  99. }
  100. inline WaterVector3Control & operator = (LLVector3 const & val) 
  101. {
  102. mX = val.mV[0];
  103. mY = val.mV[1];
  104. mZ = val.mV[2];
  105. return *this;
  106. }
  107. inline void update(LLWaterParamSet & params) const 
  108. {
  109. params.set(mName, mX, mY, mZ);
  110. }
  111. };
  112. struct WaterVector2Control 
  113. {
  114. F32 mX;
  115. F32 mY;
  116. std::string mName;
  117. // basic constructor
  118. inline WaterVector2Control(F32 valX, F32 valY, const std::string& n)
  119. : mX(valX), mY(valY), mName(n)
  120. {
  121. }
  122. inline WaterVector2Control & operator = (LLVector2 const & val) 
  123. {
  124. mX = val.mV[0];
  125. mY = val.mV[1];
  126. return *this;
  127. }
  128. inline void update(LLWaterParamSet & params) const 
  129. {
  130. params.set(mName, mX, mY);
  131. }
  132. };
  133. // float slider control
  134. struct WaterFloatControl 
  135. {
  136. F32 mX;
  137. std::string mName;
  138. F32 mMult;
  139. inline WaterFloatControl(F32 val, const std::string& n, F32 m=1.0f)
  140. : mX(val), mName(n), mMult(m)
  141. {
  142. }
  143. inline WaterFloatControl & operator = (LLVector4 const & val) 
  144. {
  145. mX = val.mV[0];
  146. return *this;
  147. }
  148. inline operator F32 (void) const 
  149. {
  150. return mX;
  151. }
  152. inline void update(LLWaterParamSet & params) const 
  153. {
  154. params.set(mName, mX);
  155. }
  156. };
  157. // float slider control
  158. struct WaterExpFloatControl 
  159. {
  160. F32 mExp;
  161. std::string mName;
  162. F32 mBase;
  163. inline WaterExpFloatControl(F32 val, const std::string& n, F32 b)
  164. : mExp(val), mName(n), mBase(b)
  165. {
  166. }
  167. inline WaterExpFloatControl & operator = (F32 val) 
  168. {
  169. mExp = log(val) / log(mBase);
  170. return *this;
  171. }
  172. inline operator F32 (void) const 
  173. {
  174. return pow(mBase, mExp);
  175. }
  176. inline void update(LLWaterParamSet & params) const 
  177. {
  178. params.set(mName, pow(mBase, mExp));
  179. }
  180. };
  181. /// WindLight parameter manager class - what controls all the wind light shaders
  182. class LLWaterParamManager
  183. {
  184. public:
  185. LLWaterParamManager();
  186. ~LLWaterParamManager();
  187. /// load a preset file
  188. void loadAllPresets(const std::string & fileName);
  189. /// load an individual preset into the sky
  190. void loadPreset(const std::string & name,bool propagate=true);
  191. /// save the parameter presets to file
  192. void savePreset(const std::string & name);
  193. /// send the parameters to the shaders
  194. void propagateParameters(void);
  195. /// update information for the shader
  196. void update(LLViewerCamera * cam);
  197. /// Update shader uniforms that have changed.
  198. void updateShaderUniforms(LLGLSLShader * shader);
  199. /// Perform global initialization for this class.
  200. static void initClass(void);
  201. // Cleanup of global data that's only inited once per class.
  202. static void cleanupClass();
  203. /// add a param to the list
  204. bool addParamSet(const std::string& name, LLWaterParamSet& param);
  205. /// add a param to the list
  206. BOOL addParamSet(const std::string& name, LLSD const & param);
  207. /// get a param from the list
  208. bool getParamSet(const std::string& name, LLWaterParamSet& param);
  209. /// set the param in the list with a new param
  210. bool setParamSet(const std::string& name, LLWaterParamSet& param);
  211. /// set the param in the list with a new param
  212. bool setParamSet(const std::string& name, LLSD const & param);
  213. /// gets rid of a parameter and any references to it
  214. /// returns true if successful
  215. bool removeParamSet(const std::string& name, bool delete_from_disk);
  216. /// set the normap map we want for water
  217. bool setNormalMapID(const LLUUID& img);
  218. void setDensitySliderValue(F32 val);
  219. /// getters for all the different things water param manager maintains
  220. LLUUID getNormalMapID(void);
  221. LLVector2 getWave1Dir(void);
  222. LLVector2 getWave2Dir(void);
  223. F32 getScaleAbove(void);
  224. F32 getScaleBelow(void);
  225. LLVector3 getNormalScale(void);
  226. F32 getFresnelScale(void);
  227. F32 getFresnelOffset(void);
  228. F32 getBlurMultiplier(void);
  229. F32 getFogDensity(void);
  230. LLColor4 getFogColor(void);
  231. // singleton pattern implementation
  232. static LLWaterParamManager * instance();
  233. public:
  234. LLWaterParamSet mCurParams;
  235. /// Atmospherics
  236. WaterColorControl mFogColor;
  237. WaterExpFloatControl mFogDensity;
  238. WaterFloatControl mUnderWaterFogMod;
  239. /// wavelet scales and directions
  240. WaterVector3Control mNormalScale;
  241. WaterVector2Control mWave1Dir;
  242. WaterVector2Control mWave2Dir;
  243. // controls how water is reflected and refracted
  244. WaterFloatControl mFresnelScale;
  245. WaterFloatControl mFresnelOffset;
  246. WaterFloatControl mScaleAbove;
  247. WaterFloatControl mScaleBelow;
  248. WaterFloatControl mBlurMultiplier;
  249. // list of all the parameters, listed by name
  250. std::map<std::string, LLWaterParamSet> mParamList;
  251. F32 mDensitySliderValue;
  252. private:
  253. LLVector4 mWaterPlane;
  254. F32 mWaterFogKS;
  255. // our parameter manager singleton instance
  256. static LLWaterParamManager * sInstance;
  257. };
  258. inline void LLWaterParamManager::setDensitySliderValue(F32 val)
  259. {
  260. val /= 10.0f;
  261. val = 1.0f - val;
  262. val *= val * val;
  263. // val *= val;
  264. mDensitySliderValue = val;
  265. }
  266. inline LLUUID LLWaterParamManager::getNormalMapID()
  267. {
  268. return mCurParams.mParamValues["normalMap"].asUUID();
  269. }
  270. inline bool LLWaterParamManager::setNormalMapID(const LLUUID& id)
  271. {
  272. mCurParams.mParamValues["normalMap"] = id;
  273. return true;
  274. }
  275. inline LLVector2 LLWaterParamManager::getWave1Dir(void)
  276. {
  277. bool err;
  278. return mCurParams.getVector2("wave1Dir", err);
  279. }
  280. inline LLVector2 LLWaterParamManager::getWave2Dir(void)
  281. {
  282. bool err;
  283. return mCurParams.getVector2("wave2Dir", err);
  284. }
  285. inline F32 LLWaterParamManager::getScaleAbove(void)
  286. {
  287. bool err;
  288. return mCurParams.getFloat("scaleAbove", err);
  289. }
  290. inline F32 LLWaterParamManager::getScaleBelow(void)
  291. {
  292. bool err;
  293. return mCurParams.getFloat("scaleBelow", err);
  294. }
  295. inline LLVector3 LLWaterParamManager::getNormalScale(void)
  296. {
  297. bool err;
  298. return mCurParams.getVector3("normScale", err);
  299. }
  300. inline F32 LLWaterParamManager::getFresnelScale(void)
  301. {
  302. bool err;
  303. return mCurParams.getFloat("fresnelScale", err);
  304. }
  305. inline F32 LLWaterParamManager::getFresnelOffset(void)
  306. {
  307. bool err;
  308. return mCurParams.getFloat("fresnelOffset", err);
  309. }
  310. inline F32 LLWaterParamManager::getBlurMultiplier(void)
  311. {
  312. bool err;
  313. return mCurParams.getFloat("blurMultiplier", err);
  314. }
  315. inline LLColor4 LLWaterParamManager::getFogColor(void)
  316. {
  317. bool err;
  318. return LLColor4(mCurParams.getVector4("waterFogColor", err));
  319. }
  320. #endif