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

游戏引擎

开发平台:

C++ Builder

  1. /**
  2.  * @file llwlparamset.cpp
  3.  * @brief Implementation for the LLWLParamSet class.
  4.  *
  5.  * $LicenseInfo:firstyear=2005&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2005-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. #include "llviewerprecompiledheaders.h"
  33. #include "llwlparamset.h"
  34. #include "llwlanimator.h"
  35. #include "llfloaterwindlight.h"
  36. #include "llwlparammanager.h"
  37. #include "lluictrlfactory.h"
  38. #include "llsliderctrl.h"
  39. #include <llgl.h>
  40. #include <sstream>
  41. LLWLParamSet::LLWLParamSet(void) :
  42. mName("Unnamed Preset"),
  43. mCloudScrollXOffset(0.f), mCloudScrollYOffset(0.f)
  44. {
  45. /* REMOVE or init the LLSD
  46. const std::map<std::string, LLVector4>::value_type hardcodedPreset[] = {
  47. std::make_pair("lightnorm", LLVector4(0.f, 0.707f, -0.707f, 0.f)),
  48. std::make_pair("sunlight_color", LLVector4(0.6f, 0.6f, 2.83f, 2.27f)),
  49. std::make_pair("ambient", LLVector4(0.27f, 0.33f, 0.44f, 1.19f)),
  50. std::make_pair("blue_horizon", LLVector4(0.3f, 0.4f, 0.9f, 1.f)),
  51. std::make_pair("blue_density", LLVector4(0.3f, 0.4f, 0.8f, 1.f)),
  52. std::make_pair("haze_horizon", LLVector4(0.6f, 0.6f, 0.6f, 1.f)),
  53. std::make_pair("haze_density", LLVector4(0.3f, 0.3f, 0.3f, 1.f)),
  54. std::make_pair("cloud_shadow", LLVector4(0.f, 0.f, 0.f, 0.f)),
  55. std::make_pair("density_multiplier", LLVector4(0.001f, 0.001f, 0.001f, 0.001f)),
  56. std::make_pair("distance_multiplier", LLVector4(1.f, 1.f, 1.f, 1.f)),
  57. std::make_pair("max_y", LLVector4(600.f, 600.f, 600.f, 0.f)),
  58. std::make_pair("glow", LLVector4(15.f, 0.001f, -0.03125f, 0.f)),
  59. std::make_pair("cloud_color", LLVector4(0.0f, 0.0f, 0.0f, 0.0f)),
  60. std::make_pair("cloud_pos_density1", LLVector4(0.f, 0.f, 0.f, 1.f)),
  61. std::make_pair("cloud_pos_density2", LLVector4(0.f, 0.f, 0.f, 1.f)),
  62. std::make_pair("cloud_scale", LLVector4(0.42f, 0.f, 0.f, 1.f)),
  63. std::make_pair("gamma", LLVector4(2.0f, 2.0f, 2.0f, 0.0f)),
  64. };
  65. std::map<std::string, LLVector4>::value_type const * endHardcodedPreset = 
  66. hardcodedPreset + LL_ARRAY_SIZE(hardcodedPreset);
  67. mParamValues.insert(hardcodedPreset, endHardcodedPreset);
  68. */
  69. }
  70. void LLWLParamSet::update(LLGLSLShader * shader) const 
  71. {
  72. for(LLSD::map_const_iterator i = mParamValues.beginMap();
  73. i != mParamValues.endMap();
  74. ++i)
  75. {
  76. const std::string& param = i->first;
  77. if( param == "star_brightness" || param == "preset_num" || param == "sun_angle" ||
  78. param == "east_angle" || param == "enable_cloud_scroll" ||
  79. param == "cloud_scroll_rate" || param == "lightnorm" ) 
  80. {
  81. continue;
  82. }
  83. if(param == "cloud_pos_density1") 
  84. {
  85. LLVector4 val;
  86. val.mV[0] = F32(i->second[0].asReal()) + mCloudScrollXOffset;
  87. val.mV[1] = F32(i->second[1].asReal()) + mCloudScrollYOffset;
  88. val.mV[2] = (F32) i->second[2].asReal();
  89. val.mV[3] = (F32) i->second[3].asReal();
  90. shader->uniform4fv(param, 1, val.mV);
  91. else 
  92. {
  93. LLVector4 val;
  94. // handle all the different cases
  95. if(i->second.isArray() && i->second.size() == 4) 
  96. {
  97. val.mV[0] = (F32) i->second[0].asReal();
  98. val.mV[1] = (F32) i->second[1].asReal();
  99. val.mV[2] = (F32) i->second[2].asReal();
  100. val.mV[3] = (F32) i->second[3].asReal();
  101. else if(i->second.isReal()) 
  102. {
  103. val.mV[0] = (F32) i->second.asReal();
  104. else if(i->second.isInteger()) 
  105. {
  106. val.mV[0] = (F32) i->second.asReal();
  107. else if(i->second.isBoolean())
  108. {
  109. val.mV[0] = i->second.asBoolean();
  110. }
  111. shader->uniform4fv(param, 1, val.mV);
  112. }
  113. }
  114. }
  115. void LLWLParamSet::set(const std::string& paramName, float x) 
  116. {
  117. // handle case where no array
  118. if(mParamValues[paramName].isReal()) 
  119. {
  120. mParamValues[paramName] = x;
  121. // handle array
  122. else if(mParamValues[paramName].isArray() &&
  123. mParamValues[paramName][0].isReal())
  124. {
  125. mParamValues[paramName][0] = x;
  126. }
  127. }
  128. void LLWLParamSet::set(const std::string& paramName, float x, float y) {
  129. mParamValues[paramName][0] = x;
  130. mParamValues[paramName][1] = y;
  131. }
  132. void LLWLParamSet::set(const std::string& paramName, float x, float y, float z) 
  133. {
  134. mParamValues[paramName][0] = x;
  135. mParamValues[paramName][1] = y;
  136. mParamValues[paramName][2] = z;
  137. }
  138. void LLWLParamSet::set(const std::string& paramName, float x, float y, float z, float w) 
  139. {
  140. mParamValues[paramName][0] = x;
  141. mParamValues[paramName][1] = y;
  142. mParamValues[paramName][2] = z;
  143. mParamValues[paramName][3] = w;
  144. }
  145. void LLWLParamSet::set(const std::string& paramName, const float * val) 
  146. {
  147. mParamValues[paramName][0] = val[0];
  148. mParamValues[paramName][1] = val[1];
  149. mParamValues[paramName][2] = val[2];
  150. mParamValues[paramName][3] = val[3];
  151. }
  152. void LLWLParamSet::set(const std::string& paramName, const LLVector4 & val) 
  153. {
  154. mParamValues[paramName][0] = val.mV[0];
  155. mParamValues[paramName][1] = val.mV[1];
  156. mParamValues[paramName][2] = val.mV[2];
  157. mParamValues[paramName][3] = val.mV[3];
  158. }
  159. void LLWLParamSet::set(const std::string& paramName, const LLColor4 & val) 
  160. {
  161. mParamValues[paramName][0] = val.mV[0];
  162. mParamValues[paramName][1] = val.mV[1];
  163. mParamValues[paramName][2] = val.mV[2];
  164. mParamValues[paramName][3] = val.mV[3];
  165. }
  166. LLVector4 LLWLParamSet::getVector(const std::string& paramName, bool& error) 
  167. {
  168. // test to see if right type
  169. LLSD cur_val = mParamValues.get(paramName);
  170. if (!cur_val.isArray()) 
  171. {
  172. error = true;
  173. return LLVector4(0,0,0,0);
  174. }
  175. LLVector4 val;
  176. val.mV[0] = (F32) cur_val[0].asReal();
  177. val.mV[1] = (F32) cur_val[1].asReal();
  178. val.mV[2] = (F32) cur_val[2].asReal();
  179. val.mV[3] = (F32) cur_val[3].asReal();
  180. error = false;
  181. return val;
  182. }
  183. F32 LLWLParamSet::getFloat(const std::string& paramName, bool& error) 
  184. {
  185. // test to see if right type
  186. LLSD cur_val = mParamValues.get(paramName);
  187. if (cur_val.isArray() && cur_val.size() != 0) 
  188. {
  189. error = false;
  190. return (F32) cur_val[0].asReal();
  191. }
  192. if(cur_val.isReal())
  193. {
  194. error = false;
  195. return (F32) cur_val.asReal();
  196. }
  197. error = true;
  198. return 0;
  199. }
  200. void LLWLParamSet::setSunAngle(float val) 
  201. {
  202. // keep range 0 - 2pi
  203. if(val > F_TWO_PI || val < 0)
  204. {
  205. F32 num = val / F_TWO_PI;
  206. num -= floor(num);
  207. val = F_TWO_PI * num;
  208. }
  209. mParamValues["sun_angle"] = val;
  210. }
  211. void LLWLParamSet::setEastAngle(float val) 
  212. {
  213. // keep range 0 - 2pi
  214. if(val > F_TWO_PI || val < 0)
  215. {
  216. F32 num = val / F_TWO_PI;
  217. num -= floor(num);
  218. val = F_TWO_PI * num;
  219. }
  220. mParamValues["east_angle"] = val;
  221. }
  222. void LLWLParamSet::mix(LLWLParamSet& src, LLWLParamSet& dest, F32 weight)
  223. {
  224. // set up the iterators
  225. LLSD::map_iterator cIt = mParamValues.beginMap();
  226. // keep cloud positions and coverage the same
  227. /// TODO masking will do this later
  228. F32 cloudPos1X = (F32) mParamValues["cloud_pos_density1"][0].asReal();
  229. F32 cloudPos1Y = (F32) mParamValues["cloud_pos_density1"][1].asReal();
  230. F32 cloudPos2X = (F32) mParamValues["cloud_pos_density2"][0].asReal();
  231. F32 cloudPos2Y = (F32) mParamValues["cloud_pos_density2"][1].asReal();
  232. F32 cloudCover = (F32) mParamValues["cloud_shadow"][0].asReal();
  233. LLSD srcVal;
  234. LLSD destVal;
  235. // do the interpolation for all the ones saved as vectors
  236. // skip the weird ones
  237. for(; cIt != mParamValues.endMap(); cIt++) {
  238. // check params to make sure they're actually there
  239. if(src.mParamValues.has(cIt->first))
  240. {
  241. srcVal = src.mParamValues[cIt->first];
  242. }
  243. else
  244. {
  245. continue;
  246. }
  247. if(dest.mParamValues.has(cIt->first))
  248. {
  249. destVal = dest.mParamValues[cIt->first];
  250. }
  251. else
  252. {
  253. continue;
  254. }
  255. // skip if not a vector
  256. if(!cIt->second.isArray()) 
  257. {
  258. continue;
  259. }
  260. // only Real vectors allowed
  261. if(!cIt->second[0].isReal()) 
  262. {
  263. continue;
  264. }
  265. // make sure all the same size
  266. if( cIt->second.size() != srcVal.size() ||
  267. cIt->second.size() != destVal.size())
  268. {
  269. continue;
  270. }
  271. // more error checking might be necessary;
  272. for(int i=0; i < cIt->second.size(); ++i) 
  273. {
  274. cIt->second[i] = (1.0f - weight) * (F32) srcVal[i].asReal() + 
  275. weight * (F32) destVal[i].asReal();
  276. }
  277. }
  278. // now mix the extra parameters
  279. setStarBrightness((1 - weight) * (F32) src.getStarBrightness()
  280. + weight * (F32) dest.getStarBrightness());
  281. llassert(src.getSunAngle() >= - F_PI && 
  282. src.getSunAngle() <= 3 * F_PI);
  283. llassert(dest.getSunAngle() >= - F_PI && 
  284. dest.getSunAngle() <= 3 * F_PI);
  285. llassert(src.getEastAngle() >= 0 && 
  286. src.getEastAngle() <= 4 * F_PI);
  287. llassert(dest.getEastAngle() >= 0 && 
  288. dest.getEastAngle() <= 4 * F_PI);
  289. // sun angle and east angle require some handling to make sure
  290. // they go in circles.  Yes quaternions would work better.
  291. F32 srcSunAngle = src.getSunAngle();
  292. F32 destSunAngle = dest.getSunAngle();
  293. F32 srcEastAngle = src.getEastAngle();
  294. F32 destEastAngle = dest.getEastAngle();
  295. if(fabsf(srcSunAngle - destSunAngle) > F_PI) 
  296. {
  297. if(srcSunAngle > destSunAngle) 
  298. {
  299. destSunAngle += 2 * F_PI;
  300. else 
  301. {
  302. srcSunAngle += 2 * F_PI;
  303. }
  304. }
  305. if(fabsf(srcEastAngle - destEastAngle) > F_PI) 
  306. {
  307. if(srcEastAngle > destEastAngle) 
  308. {
  309. destEastAngle += 2 * F_PI;
  310. else 
  311. {
  312. srcEastAngle += 2 * F_PI;
  313. }
  314. }
  315. setSunAngle((1 - weight) * srcSunAngle + weight * destSunAngle);
  316. setEastAngle((1 - weight) * srcEastAngle + weight * destEastAngle);
  317. // now setup the sun properly
  318. // reset those cloud positions
  319. mParamValues["cloud_pos_density1"][0] = cloudPos1X;
  320. mParamValues["cloud_pos_density1"][1] = cloudPos1Y;
  321. mParamValues["cloud_pos_density2"][0] = cloudPos2X;
  322. mParamValues["cloud_pos_density2"][1] = cloudPos2Y;
  323. mParamValues["cloud_shadow"][0] = cloudCover;
  324. }
  325. void LLWLParamSet::updateCloudScrolling(void) 
  326. {
  327. static LLTimer s_cloud_timer;
  328. F64 delta_t = s_cloud_timer.getElapsedTimeAndResetF64();
  329. if(getEnableCloudScrollX())
  330. {
  331. mCloudScrollXOffset += F32(delta_t * (getCloudScrollX() - 10.f) / 100.f);
  332. }
  333. if(getEnableCloudScrollY())
  334. {
  335. mCloudScrollYOffset += F32(delta_t * (getCloudScrollY() - 10.f) / 100.f);
  336. }
  337. }