开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llfloaterwindlight.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：30k
源码类别：

游戏引擎

开发平台：

C++ Builder

llfloaterwindlight.cpp：源码内容
  1. /** 
  2.  * @file llfloaterwindlight.cpp
  3.  * @brief LLFloaterWindLight class definition
  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.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "llfloaterwindlight.h"
  37. #include "pipeline.h"
  38. #include "llsky.h"
  40. #include "llfloaterreg.h"
  41. #include "llsliderctrl.h"
  42. #include "llmultislider.h"
  43. #include "llmultisliderctrl.h"
  44. #include "llnotificationsutil.h"
  45. #include "llspinctrl.h"
  46. #include "llcheckboxctrl.h"
  47. #include "lluictrlfactory.h"
  48. #include "llviewercamera.h"
  49. #include "llcombobox.h"
  50. #include "lllineeditor.h"
  51. #include "llfloaterdaycycle.h"
  52. #include "llboost.h"
  54. #include "v4math.h"
  55. #include "llviewerdisplay.h"
  56. #include "llviewercontrol.h"
  57. #include "llviewerwindow.h"
  58. #include "llsavedsettingsglue.h"
  60. #include "llwlparamset.h"
  61. #include "llwlparammanager.h"
  62. #include "llpostprocess.h"
  63. #include "lltabcontainer.h"
  66. #undef max
  68. std::set<std::string> LLFloaterWindLight::sDefaultPresets;
  70. static const F32 WL_SUN_AMBIENT_SLIDER_SCALE = 3.0f;
  72. LLFloaterWindLight::LLFloaterWindLight(const LLSD& key)
  73.   : LLFloater(key)
  74. {
  75. //LLUICtrlFactory::getInstance()->buildFloater(this, "floater_windlight_options.xml");
  76. }
  78. LLFloaterWindLight::~LLFloaterWindLight()
  79. {
  80. }
  82. BOOL LLFloaterWindLight::postBuild()
  83. {
  84. // add the list of presets
  85. std::string def_days = getString("WLDefaultSkyNames");
  87. // no editing or deleting of the blank string
  88. sDefaultPresets.insert("");
  89. boost_tokenizer tokens(def_days, boost::char_separator<char>(":"));
  90. for (boost_tokenizer::iterator token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
  91. {
  92. std::string tok(*token_iter);
  93. sDefaultPresets.insert(tok);
  94. }
  96. // add the combo boxes
  97. LLComboBox* comboBox = getChild<LLComboBox>("WLPresetsCombo");
  99. if(comboBox != NULL) {
  101. std::map<std::string, LLWLParamSet>::iterator mIt = 
  102. LLWLParamManager::instance()->mParamList.begin();
  103. for(; mIt != LLWLParamManager::instance()->mParamList.end(); mIt++) 
  104. {
  105. comboBox->add(mIt->first);
  106. }
  108. // entry for when we're in estate time
  109. comboBox->add(LLStringUtil::null);
  111. // set defaults on combo boxes
  112. comboBox->selectByValue(LLSD("Default"));
  113. }
  114. // load it up
  115. initCallbacks();
  117. syncMenu();
  119. return TRUE;
  120. }
  121. void LLFloaterWindLight::initCallbacks(void) {
  123. LLWLParamManager * param_mgr = LLWLParamManager::instance();
  125. // blue horizon
  126. getChild<LLUICtrl>("WLBlueHorizonR")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr->mBlueHorizon));
  127. getChild<LLUICtrl>("WLBlueHorizonG")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr->mBlueHorizon));
  128. getChild<LLUICtrl>("WLBlueHorizonB")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr->mBlueHorizon));
  129. getChild<LLUICtrl>("WLBlueHorizonI")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlIMoved, this, _1, &param_mgr->mBlueHorizon));
  131. // haze density, horizon, mult, and altitude
  132. getChild<LLUICtrl>("WLHazeDensity")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr->mHazeDensity));
  133. getChild<LLUICtrl>("WLHazeHorizon")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr->mHazeHorizon));
  134. getChild<LLUICtrl>("WLDensityMult")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr->mDensityMult));
  135. getChild<LLUICtrl>("WLMaxAltitude")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr->mMaxAlt));
  137. // blue density
  138. getChild<LLUICtrl>("WLBlueDensityR")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr->mBlueDensity));
  139. getChild<LLUICtrl>("WLBlueDensityG")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr->mBlueDensity));
  140. getChild<LLUICtrl>("WLBlueDensityB")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr->mBlueDensity));
  141. getChild<LLUICtrl>("WLBlueDensityI")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlIMoved, this, _1, &param_mgr->mBlueDensity));
  143. // Lighting
  145. // sunlight
  146. getChild<LLUICtrl>("WLSunlightR")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr->mSunlight));
  147. getChild<LLUICtrl>("WLSunlightG")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr->mSunlight));
  148. getChild<LLUICtrl>("WLSunlightB")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr->mSunlight));
  149. getChild<LLUICtrl>("WLSunlightI")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlIMoved, this, _1, &param_mgr->mSunlight));
  151. // glow
  152. getChild<LLUICtrl>("WLGlowR")->setCommitCallback(boost::bind(&LLFloaterWindLight::onGlowRMoved, this, _1, &param_mgr->mGlow));
  153. getChild<LLUICtrl>("WLGlowB")->setCommitCallback(boost::bind(&LLFloaterWindLight::onGlowBMoved, this, _1, &param_mgr->mGlow));
  155. // ambient
  156. getChild<LLUICtrl>("WLAmbientR")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr->mAmbient));
  157. getChild<LLUICtrl>("WLAmbientG")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr->mAmbient));
  158. getChild<LLUICtrl>("WLAmbientB")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr->mAmbient));
  159. getChild<LLUICtrl>("WLAmbientI")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlIMoved, this, _1, &param_mgr->mAmbient));
  161. // time of day
  162. getChild<LLUICtrl>("WLSunAngle")->setCommitCallback(boost::bind(&LLFloaterWindLight::onSunMoved, this, _1, &param_mgr->mLightnorm));
  163. getChild<LLUICtrl>("WLEastAngle")->setCommitCallback(boost::bind(&LLFloaterWindLight::onSunMoved, this, _1, &param_mgr->mLightnorm));
  165. // Clouds
  167. // Cloud Color
  168. getChild<LLUICtrl>("WLCloudColorR")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr->mCloudColor));
  169. getChild<LLUICtrl>("WLCloudColorG")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr->mCloudColor));
  170. getChild<LLUICtrl>("WLCloudColorB")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr->mCloudColor));
  171. getChild<LLUICtrl>("WLCloudColorI")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlIMoved, this, _1, &param_mgr->mCloudColor));
  173. // Cloud
  174. getChild<LLUICtrl>("WLCloudX")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr->mCloudMain));
  175. getChild<LLUICtrl>("WLCloudY")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr->mCloudMain));
  176. getChild<LLUICtrl>("WLCloudDensity")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr->mCloudMain));
  178. // Cloud Detail
  179. getChild<LLUICtrl>("WLCloudDetailX")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr->mCloudDetail));
  180. getChild<LLUICtrl>("WLCloudDetailY")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr->mCloudDetail));
  181. getChild<LLUICtrl>("WLCloudDetailDensity")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr->mCloudDetail));
  183. // Cloud extras
  184. getChild<LLUICtrl>("WLCloudCoverage")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr->mCloudCoverage));
  185. getChild<LLUICtrl>("WLCloudScale")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr->mCloudScale));
  186. getChild<LLUICtrl>("WLCloudLockX")->setCommitCallback(boost::bind(&LLFloaterWindLight::onCloudScrollXToggled, this, _1));
  187. getChild<LLUICtrl>("WLCloudLockY")->setCommitCallback(boost::bind(&LLFloaterWindLight::onCloudScrollYToggled, this, _1));
  188. getChild<LLUICtrl>("WLCloudScrollX")->setCommitCallback(boost::bind(&LLFloaterWindLight::onCloudScrollXMoved, this, _1));
  189. getChild<LLUICtrl>("WLCloudScrollY")->setCommitCallback(boost::bind(&LLFloaterWindLight::onCloudScrollYMoved, this, _1));
  190. getChild<LLUICtrl>("WLDistanceMult")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr->mDistanceMult));
  191. getChild<LLUICtrl>("DrawClassicClouds")->setCommitCallback(boost::bind(LLSavedSettingsGlue::setBOOL, _1, "SkyUseClassicClouds"));
  193. // WL Top
  194. getChild<LLUICtrl>("WLDayCycleMenuButton")->setCommitCallback(boost::bind(&LLFloaterWindLight::onOpenDayCycle, this));
  195. // Load/save
  196. LLComboBox* comboBox = getChild<LLComboBox>("WLPresetsCombo");
  198. //childSetAction("WLLoadPreset", onLoadPreset, comboBox);
  199. getChild<LLUICtrl>("WLNewPreset")->setCommitCallback(boost::bind(&LLFloaterWindLight::onNewPreset, this));
  200. getChild<LLUICtrl>("WLSavePreset")->setCommitCallback(boost::bind(&LLFloaterWindLight::onSavePreset, this));
  201. getChild<LLUICtrl>("WLDeletePreset")->setCommitCallback(boost::bind(&LLFloaterWindLight::onDeletePreset, this));
  203. comboBox->setCommitCallback(boost::bind(&LLFloaterWindLight::onChangePresetName, this, _1));
  206. // Dome
  207. getChild<LLUICtrl>("WLGamma")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr->mWLGamma));
  208. getChild<LLUICtrl>("WLStarAlpha")->setCommitCallback(boost::bind(&LLFloaterWindLight::onStarAlphaMoved, this, _1));
  209. }
  211. bool LLFloaterWindLight::newPromptCallback(const LLSD& notification, const LLSD& response)
  212. {
  213. std::string text = response["message"].asString();
  214. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  216. if(text == "")
  217. {
  218. return false;
  219. }
  221. if(option == 0) {
  222. LLComboBox* comboBox = getChild<LLComboBox>("WLPresetsCombo");
  224. LLFloaterDayCycle* day_cycle = LLFloaterReg::findTypedInstance<LLFloaterDayCycle>("env_day_cycle");
  225. LLComboBox* keyCombo = NULL;
  226. if(day_cycle) 
  227. {
  228. keyCombo = day_cycle->getChild<LLComboBox>("WLKeyPresets");
  229. }
  231. // add the current parameters to the list
  232. // see if it's there first
  233. std::map<std::string, LLWLParamSet>::iterator mIt = 
  234. LLWLParamManager::instance()->mParamList.find(text);
  236. // if not there, add a new one
  237. if(mIt == LLWLParamManager::instance()->mParamList.end()) 
  238. {
  239. LLWLParamManager::instance()->addParamSet(text, 
  240. LLWLParamManager::instance()->mCurParams);
  241. comboBox->add(text);
  242. comboBox->sortByName();
  244. // add a blank to the bottom
  245. comboBox->selectFirstItem();
  246. if(comboBox->getSimple() == "")
  247. {
  248. comboBox->remove(0);
  249. }
  250. comboBox->add(LLStringUtil::null);
  252. comboBox->setSelectedByValue(text, true);
  253. if(keyCombo) 
  254. {
  255. keyCombo->add(text);
  256. keyCombo->sortByName();
  257. }
  258. LLWLParamManager::instance()->savePreset(text);
  260. // otherwise, send a message to the user
  261. } 
  262. else 
  263. {
  264. LLNotificationsUtil::add("ExistsSkyPresetAlert");
  265. }
  266. }
  267. return false;
  268. }
  270. void LLFloaterWindLight::syncMenu()
  271. {
  272. bool err;
  274. LLWLParamManager * param_mgr = LLWLParamManager::instance();
  276. LLWLParamSet& currentParams = param_mgr->mCurParams;
  277. //std::map<std::string, LLVector4> & currentParams = param_mgr->mCurParams.mParamValues;
  279. // blue horizon
  280. param_mgr->mBlueHorizon = currentParams.getVector(param_mgr->mBlueHorizon.mName, err);
  281. childSetValue("WLBlueHorizonR", param_mgr->mBlueHorizon.r / 2.0);
  282. childSetValue("WLBlueHorizonG", param_mgr->mBlueHorizon.g / 2.0);
  283. childSetValue("WLBlueHorizonB", param_mgr->mBlueHorizon.b / 2.0);
  284. childSetValue("WLBlueHorizonI", 
  285. std::max(param_mgr->mBlueHorizon.r / 2.0, 
  286. std::max(param_mgr->mBlueHorizon.g / 2.0, 
  287. param_mgr->mBlueHorizon.b / 2.0)));
  289. // haze density, horizon, mult, and altitude
  290. param_mgr->mHazeDensity = currentParams.getVector(param_mgr->mHazeDensity.mName, err);
  291. childSetValue("WLHazeDensity", param_mgr->mHazeDensity.r);
  292. param_mgr->mHazeHorizon = currentParams.getVector(param_mgr->mHazeHorizon.mName, err);
  293. childSetValue("WLHazeHorizon", param_mgr->mHazeHorizon.r);
  294. param_mgr->mDensityMult = currentParams.getVector(param_mgr->mDensityMult.mName, err);
  295. childSetValue("WLDensityMult", param_mgr->mDensityMult.x * 
  296. param_mgr->mDensityMult.mult);
  297. param_mgr->mMaxAlt = currentParams.getVector(param_mgr->mMaxAlt.mName, err);
  298. childSetValue("WLMaxAltitude", param_mgr->mMaxAlt.x);
  300. // blue density
  301. param_mgr->mBlueDensity = currentParams.getVector(param_mgr->mBlueDensity.mName, err);
  302. childSetValue("WLBlueDensityR", param_mgr->mBlueDensity.r / 2.0);
  303. childSetValue("WLBlueDensityG", param_mgr->mBlueDensity.g / 2.0);
  304. childSetValue("WLBlueDensityB", param_mgr->mBlueDensity.b / 2.0);
  305. childSetValue("WLBlueDensityI", 
  306. std::max(param_mgr->mBlueDensity.r / 2.0, 
  307. std::max(param_mgr->mBlueDensity.g / 2.0, param_mgr->mBlueDensity.b / 2.0)));
  309. // Lighting
  311. // sunlight
  312. param_mgr->mSunlight = currentParams.getVector(param_mgr->mSunlight.mName, err);
  313. childSetValue("WLSunlightR", param_mgr->mSunlight.r / WL_SUN_AMBIENT_SLIDER_SCALE);
  314. childSetValue("WLSunlightG", param_mgr->mSunlight.g / WL_SUN_AMBIENT_SLIDER_SCALE);
  315. childSetValue("WLSunlightB", param_mgr->mSunlight.b / WL_SUN_AMBIENT_SLIDER_SCALE);
  316. childSetValue("WLSunlightI", 
  317. std::max(param_mgr->mSunlight.r / WL_SUN_AMBIENT_SLIDER_SCALE, 
  318. std::max(param_mgr->mSunlight.g / WL_SUN_AMBIENT_SLIDER_SCALE, param_mgr->mSunlight.b / WL_SUN_AMBIENT_SLIDER_SCALE)));
  320. // glow
  321. param_mgr->mGlow = currentParams.getVector(param_mgr->mGlow.mName, err);
  322. childSetValue("WLGlowR", 2 - param_mgr->mGlow.r / 20.0f);
  323. childSetValue("WLGlowB", -param_mgr->mGlow.b / 5.0f);
  325. // ambient
  326. param_mgr->mAmbient = currentParams.getVector(param_mgr->mAmbient.mName, err);
  327. childSetValue("WLAmbientR", param_mgr->mAmbient.r / WL_SUN_AMBIENT_SLIDER_SCALE);
  328. childSetValue("WLAmbientG", param_mgr->mAmbient.g / WL_SUN_AMBIENT_SLIDER_SCALE);
  329. childSetValue("WLAmbientB", param_mgr->mAmbient.b / WL_SUN_AMBIENT_SLIDER_SCALE);
  330. childSetValue("WLAmbientI", 
  331. std::max(param_mgr->mAmbient.r / WL_SUN_AMBIENT_SLIDER_SCALE, 
  332. std::max(param_mgr->mAmbient.g / WL_SUN_AMBIENT_SLIDER_SCALE, param_mgr->mAmbient.b / WL_SUN_AMBIENT_SLIDER_SCALE)));
  334. childSetValue("WLSunAngle", param_mgr->mCurParams.getFloat("sun_angle",err) / F_TWO_PI);
  335. childSetValue("WLEastAngle", param_mgr->mCurParams.getFloat("east_angle",err) / F_TWO_PI);
  337. // Clouds
  339. // Cloud Color
  340. param_mgr->mCloudColor = currentParams.getVector(param_mgr->mCloudColor.mName, err);
  341. childSetValue("WLCloudColorR", param_mgr->mCloudColor.r);
  342. childSetValue("WLCloudColorG", param_mgr->mCloudColor.g);
  343. childSetValue("WLCloudColorB", param_mgr->mCloudColor.b);
  344. childSetValue("WLCloudColorI", 
  345. std::max(param_mgr->mCloudColor.r, 
  346. std::max(param_mgr->mCloudColor.g, param_mgr->mCloudColor.b)));
  348. // Cloud
  349. param_mgr->mCloudMain = currentParams.getVector(param_mgr->mCloudMain.mName, err);
  350. childSetValue("WLCloudX", param_mgr->mCloudMain.r);
  351. childSetValue("WLCloudY", param_mgr->mCloudMain.g);
  352. childSetValue("WLCloudDensity", param_mgr->mCloudMain.b);
  354. // Cloud Detail
  355. param_mgr->mCloudDetail = currentParams.getVector(param_mgr->mCloudDetail.mName, err);
  356. childSetValue("WLCloudDetailX", param_mgr->mCloudDetail.r);
  357. childSetValue("WLCloudDetailY", param_mgr->mCloudDetail.g);
  358. childSetValue("WLCloudDetailDensity", param_mgr->mCloudDetail.b);
  360. // Cloud extras
  361. param_mgr->mCloudCoverage = currentParams.getVector(param_mgr->mCloudCoverage.mName, err);
  362. param_mgr->mCloudScale = currentParams.getVector(param_mgr->mCloudScale.mName, err);
  363. childSetValue("WLCloudCoverage", param_mgr->mCloudCoverage.x);
  364. childSetValue("WLCloudScale", param_mgr->mCloudScale.x);
  366. // cloud scrolling
  367. bool lockX = !param_mgr->mCurParams.getEnableCloudScrollX();
  368. bool lockY = !param_mgr->mCurParams.getEnableCloudScrollY();
  369. childSetValue("WLCloudLockX", lockX);
  370. childSetValue("WLCloudLockY", lockY);
  371. childSetValue("DrawClassicClouds", gSavedSettings.getBOOL("SkyUseClassicClouds"));
  373. // disable if locked, enable if not
  374. if(lockX) 
  375. {
  376. childDisable("WLCloudScrollX");
  377. } else {
  378. childEnable("WLCloudScrollX");
  379. }
  380. if(lockY)
  381. {
  382. childDisable("WLCloudScrollY");
  383. } else {
  384. childEnable("WLCloudScrollY");
  385. }
  387. // *HACK cloud scrolling is off my an additive of 10
  388. childSetValue("WLCloudScrollX", param_mgr->mCurParams.getCloudScrollX() - 10.0f);
  389. childSetValue("WLCloudScrollY", param_mgr->mCurParams.getCloudScrollY() - 10.0f);
  391. param_mgr->mDistanceMult = currentParams.getVector(param_mgr->mDistanceMult.mName, err);
  392. childSetValue("WLDistanceMult", param_mgr->mDistanceMult.x);
  394. // Tweak extras
  396. param_mgr->mWLGamma = currentParams.getVector(param_mgr->mWLGamma.mName, err);
  397. childSetValue("WLGamma", param_mgr->mWLGamma.x);
  399. childSetValue("WLStarAlpha", param_mgr->mCurParams.getStarBrightness());
  401. LLTabContainer* tab = getChild<LLTabContainer>("WindLight Tabs");
  402. LLPanel* panel = getChild<LLPanel>("Scattering");
  404. tab->enableTabButton(tab->getIndexForPanel(panel), gSavedSettings.getBOOL("RenderDeferredGI"));
  405. }
  408. // color control callbacks
  409. void LLFloaterWindLight::onColorControlRMoved(LLUICtrl* ctrl, WLColorControl* colorControl)
  410. {
  411. deactivateAnimator();
  413. LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
  415. colorControl->r = sldrCtrl->getValueF32();
  416. if(colorControl->isSunOrAmbientColor) {
  417. colorControl->r *= 3;
  418. }
  419. if(colorControl->isBlueHorizonOrDensity) {
  420. colorControl->r *= 2;
  421. }
  423. // move i if it's the max
  424. if(colorControl->r >= colorControl->g && colorControl->r >= colorControl->b 
  425. && colorControl->hasSliderName) {
  426. colorControl->i = colorControl->r;
  427. std::string name = colorControl->mSliderName;
  428. name.append("I");
  430. if(colorControl->isSunOrAmbientColor) {
  431. childSetValue(name, colorControl->r / 3);
  432. } else if(colorControl->isBlueHorizonOrDensity) {
  433. childSetValue(name, colorControl->r / 2);
  434. } else {
  435. childSetValue(name, colorControl->r);
  436. }
  437. }
  439. colorControl->update(LLWLParamManager::instance()->mCurParams);
  441. LLWLParamManager::instance()->propagateParameters();
  442. }
  444. void LLFloaterWindLight::onColorControlGMoved(LLUICtrl* ctrl, WLColorControl* colorControl)
  445. {
  446. deactivateAnimator();
  448. LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
  450. colorControl->g = sldrCtrl->getValueF32();
  451. if(colorControl->isSunOrAmbientColor) {
  452. colorControl->g *= 3;
  453. }
  454. if(colorControl->isBlueHorizonOrDensity) {
  455. colorControl->g *= 2;
  456. }
  458. // move i if it's the max
  459. if(colorControl->g >= colorControl->r && colorControl->g >= colorControl->b
  460. && colorControl->hasSliderName) {
  461. colorControl->i = colorControl->g;
  462. std::string name = colorControl->mSliderName;
  463. name.append("I");
  465. if(colorControl->isSunOrAmbientColor) {
  466. childSetValue(name, colorControl->g / 3);
  467. } else if(colorControl->isBlueHorizonOrDensity) {
  468. childSetValue(name, colorControl->g / 2);
  469. } else {
  470. childSetValue(name, colorControl->g);
  471. }
  472. }
  474. colorControl->update(LLWLParamManager::instance()->mCurParams);
  476. LLWLParamManager::instance()->propagateParameters();
  477. }
  479. void LLFloaterWindLight::onColorControlBMoved(LLUICtrl* ctrl, WLColorControl* colorControl)
  480. {
  481. deactivateAnimator();
  483. LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
  485. colorControl->b = sldrCtrl->getValueF32();
  486. if(colorControl->isSunOrAmbientColor) {
  487. colorControl->b *= 3;
  488. }
  489. if(colorControl->isBlueHorizonOrDensity) {
  490. colorControl->b *= 2;
  491. }
  493. // move i if it's the max
  494. if(colorControl->b >= colorControl->r && colorControl->b >= colorControl->g
  495. && colorControl->hasSliderName) {
  496. colorControl->i = colorControl->b;
  497. std::string name = colorControl->mSliderName;
  498. name.append("I");
  500. if(colorControl->isSunOrAmbientColor) {
  501. childSetValue(name, colorControl->b / 3);
  502. } else if(colorControl->isBlueHorizonOrDensity) {
  503. childSetValue(name, colorControl->b / 2);
  504. } else {
  505. childSetValue(name, colorControl->b);
  506. }
  507. }
  509. colorControl->update(LLWLParamManager::instance()->mCurParams);
  511. LLWLParamManager::instance()->propagateParameters();
  512. }
  514. void LLFloaterWindLight::onColorControlIMoved(LLUICtrl* ctrl, WLColorControl* colorControl)
  515. {
  516. deactivateAnimator();
  518. LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
  520. colorControl->i = sldrCtrl->getValueF32();
  522. // only for sliders where we pass a name
  523. if(colorControl->hasSliderName) {
  525. // set it to the top
  526. F32 maxVal = std::max(std::max(colorControl->r, colorControl->g), colorControl->b);
  527. F32 iVal;
  529. if(colorControl->isSunOrAmbientColor)
  530. {
  531. iVal = colorControl->i * 3;
  532. } 
  533. else if(colorControl->isBlueHorizonOrDensity)
  534. {
  535. iVal = colorControl->i * 2;
  536. } 
  537. else 
  538. {
  539. iVal = colorControl->i;
  540. }
  542. // get the names of the other sliders
  543. std::string rName = colorControl->mSliderName;
  544. rName.append("R");
  545. std::string gName = colorControl->mSliderName;
  546. gName.append("G");
  547. std::string bName = colorControl->mSliderName;
  548. bName.append("B");
  550. // handle if at 0
  551. if(iVal == 0) {
  552. colorControl->r = 0;
  553. colorControl->g = 0;
  554. colorControl->b = 0;
  556. // if all at the start
  557. // set them all to the intensity
  558. } else if (maxVal == 0) {
  559. colorControl->r = iVal;
  560. colorControl->g = iVal;
  561. colorControl->b = iVal;
  563. } else {
  565. // add delta amounts to each
  566. F32 delta = (iVal - maxVal) / maxVal;
  567. colorControl->r *= (1.0f + delta);
  568. colorControl->g *= (1.0f + delta);
  569. colorControl->b *= (1.0f + delta);
  570. }
  572. // divide sun color vals by three
  573. if(colorControl->isSunOrAmbientColor) 
  574. {
  575. childSetValue(rName, colorControl->r/3);
  576. childSetValue(gName, colorControl->g/3);
  577. childSetValue(bName, colorControl->b/3);
  579. } 
  580. else if(colorControl->isBlueHorizonOrDensity) 
  581. {
  582. childSetValue(rName, colorControl->r/2);
  583. childSetValue(gName, colorControl->g/2);
  584. childSetValue(bName, colorControl->b/2);
  586. } 
  587. else 
  588. {
  589. // set the sliders to the new vals
  590. childSetValue(rName, colorControl->r);
  591. childSetValue(gName, colorControl->g);
  592. childSetValue(bName, colorControl->b);
  593. }
  594. }
  596. // now update the current parameters and send them to shaders
  597. colorControl->update(LLWLParamManager::instance()->mCurParams);
  598. LLWLParamManager::instance()->propagateParameters();
  599. }
  601. /// GLOW SPECIFIC CODE
  602. void LLFloaterWindLight::onGlowRMoved(LLUICtrl* ctrl, WLColorControl* colorControl)
  603. {
  604. deactivateAnimator();
  606. LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
  608. // scaled by 20
  609. colorControl->r = (2 - sldrCtrl->getValueF32()) * 20;
  611. colorControl->update(LLWLParamManager::instance()->mCurParams);
  612. LLWLParamManager::instance()->propagateParameters();
  613. }
  615. /// NOTE that we want NEGATIVE (-) B
  616. void LLFloaterWindLight::onGlowBMoved(LLUICtrl* ctrl, WLColorControl* colorControl)
  617. {
  618. deactivateAnimator();
  620. LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
  622. /// NOTE that we want NEGATIVE (-) B and NOT by 20 as 20 is too big
  623. colorControl->b = -sldrCtrl->getValueF32() * 5;
  625. colorControl->update(LLWLParamManager::instance()->mCurParams);
  626. LLWLParamManager::instance()->propagateParameters();
  627. }
  629. void LLFloaterWindLight::onFloatControlMoved(LLUICtrl* ctrl, WLFloatControl* floatControl)
  630. {
  631. deactivateAnimator();
  633. LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
  635. floatControl->x = sldrCtrl->getValueF32() / floatControl->mult;
  637. floatControl->update(LLWLParamManager::instance()->mCurParams);
  638. LLWLParamManager::instance()->propagateParameters();
  639. }
  641. // Lighting callbacks
  643. // time of day
  644. void LLFloaterWindLight::onSunMoved(LLUICtrl* ctrl, WLColorControl* colorControl)
  645. {
  646. deactivateAnimator();
  648. LLSliderCtrl* sunSldr = getChild<LLSliderCtrl>("WLSunAngle");
  649. LLSliderCtrl* eastSldr = getChild<LLSliderCtrl>("WLEastAngle");
  651. // get the two angles
  652. LLWLParamManager * param_mgr = LLWLParamManager::instance();
  654. param_mgr->mCurParams.setSunAngle(F_TWO_PI * sunSldr->getValueF32());
  655. param_mgr->mCurParams.setEastAngle(F_TWO_PI * eastSldr->getValueF32());
  657. // set the sun vector
  658. colorControl->r = -sin(param_mgr->mCurParams.getEastAngle()) * 
  659. cos(param_mgr->mCurParams.getSunAngle());
  660. colorControl->g = sin(param_mgr->mCurParams.getSunAngle());
  661. colorControl->b = cos(param_mgr->mCurParams.getEastAngle()) * 
  662. cos(param_mgr->mCurParams.getSunAngle());
  663. colorControl->i = 1.f;
  665. colorControl->update(param_mgr->mCurParams);
  666. param_mgr->propagateParameters();
  667. }
  669. void LLFloaterWindLight::onStarAlphaMoved(LLUICtrl* ctrl)
  670. {
  671. deactivateAnimator();
  673. LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
  675. LLWLParamManager::instance()->mCurParams.setStarBrightness(sldrCtrl->getValueF32());
  676. }
  678. void LLFloaterWindLight::onNewPreset()
  679. {
  680. LLNotificationsUtil::add("NewSkyPreset", LLSD(), LLSD(), boost::bind(&LLFloaterWindLight::newPromptCallback, this, _1, _2));
  681. }
  683. void LLFloaterWindLight::onSavePreset()
  684. {
  685. // get the name
  686. LLComboBox* comboBox = getChild<LLComboBox>( 
  687. "WLPresetsCombo");
  689. // don't save the empty name
  690. if(comboBox->getSelectedItemLabel() == "")
  691. {
  692. return;
  693. }
  695. // check to see if it's a default and shouldn't be overwritten
  696. std::set<std::string>::iterator sIt = sDefaultPresets.find(
  697. comboBox->getSelectedItemLabel());
  698. if(sIt != sDefaultPresets.end() && !gSavedSettings.getBOOL("SkyEditPresets")) 
  699. {
  700. LLNotificationsUtil::add("WLNoEditDefault");
  701. return;
  702. }
  704. LLWLParamManager::instance()->mCurParams.mName = 
  705. comboBox->getSelectedItemLabel();
  707. LLNotificationsUtil::add("WLSavePresetAlert", LLSD(), LLSD(), boost::bind(&LLFloaterWindLight::saveAlertCallback, this, _1, _2));
  708. }
  710. bool LLFloaterWindLight::saveAlertCallback(const LLSD& notification, const LLSD& response)
  711. {
  712. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  713. // if they choose save, do it.  Otherwise, don't do anything
  714. if(option == 0) 
  715. {
  716. LLWLParamManager * param_mgr = LLWLParamManager::instance();
  718. param_mgr->setParamSet(param_mgr->mCurParams.mName, param_mgr->mCurParams);
  720. // comment this back in to save to file
  721. param_mgr->savePreset(param_mgr->mCurParams.mName);
  722. }
  723. return false;
  724. }
  726. void LLFloaterWindLight::onDeletePreset()
  727. {
  728. LLComboBox* combo_box = getChild<LLComboBox>( 
  729. "WLPresetsCombo");
  731. if(combo_box->getSelectedValue().asString() == "")
  732. {
  733. return;
  734. }
  736. LLSD args;
  737. args["SKY"] = combo_box->getSelectedValue().asString();
  738. LLNotificationsUtil::add("WLDeletePresetAlert", args, LLSD(), 
  739. boost::bind(&LLFloaterWindLight::deleteAlertCallback, this, _1, _2));
  740. }
  742. bool LLFloaterWindLight::deleteAlertCallback(const LLSD& notification, const LLSD& response)
  743. {
  744. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  746. // if they choose delete, do it.  Otherwise, don't do anything
  747. if(option == 0) 
  748. {
  749. LLComboBox* combo_box = getChild<LLComboBox>("WLPresetsCombo");
  750. LLFloaterDayCycle* day_cycle = LLFloaterReg::findTypedInstance<LLFloaterDayCycle>("env_day_cycle");
  751. LLComboBox* key_combo = NULL;
  753. if (day_cycle) 
  754. {
  755. key_combo = day_cycle->getChild<LLComboBox>("WLKeyPresets");
  756. }
  758. std::string name(combo_box->getSelectedValue().asString());
  760. // check to see if it's a default and shouldn't be deleted
  761. std::set<std::string>::iterator sIt = sDefaultPresets.find(name);
  762. if(sIt != sDefaultPresets.end()) 
  763. {
  764. LLNotificationsUtil::add("WLNoEditDefault");
  765. return false;
  766. }
  768. LLWLParamManager::instance()->removeParamSet(name, true);
  770. // remove and choose another
  771. S32 new_index = combo_box->getCurrentIndex();
  773. combo_box->remove(name);
  774. if(key_combo != NULL) 
  775. {
  776. key_combo->remove(name);
  778. // remove from slider, as well
  779. day_cycle->deletePreset(name);
  780. }
  782. // pick the previously selected index after delete
  783. if(new_index > 0) 
  784. {
  785. new_index--;
  786. }
  788. if(combo_box->getItemCount() > 0) 
  789. {
  790. combo_box->setCurrentByIndex(new_index);
  791. }
  792. }
  793. return false;
  794. }
  797. void LLFloaterWindLight::onChangePresetName(LLUICtrl* ctrl)
  798. {
  799. deactivateAnimator();
  801. std::string data = ctrl->getValue().asString();
  802. if(!data.empty())
  803. {
  804. LLWLParamManager::instance()->loadPreset( data);
  805. syncMenu();
  806. }
  807. }
  809. void LLFloaterWindLight::onOpenDayCycle()
  810. {
  811. LLFloaterReg::showInstance("env_day_cycle");
  812. }
  814. // Clouds
  815. void LLFloaterWindLight::onCloudScrollXMoved(LLUICtrl* ctrl)
  816. {
  817. deactivateAnimator();
  819. LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
  820. // *HACK  all cloud scrolling is off by an additive of 10. 
  821. LLWLParamManager::instance()->mCurParams.setCloudScrollX(sldrCtrl->getValueF32() + 10.0f);
  822. }
  824. void LLFloaterWindLight::onCloudScrollYMoved(LLUICtrl* ctrl)
  825. {
  826. deactivateAnimator();
  828. LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
  830. // *HACK  all cloud scrolling is off by an additive of 10. 
  831. LLWLParamManager::instance()->mCurParams.setCloudScrollY(sldrCtrl->getValueF32() + 10.0f);
  832. }
  834. void LLFloaterWindLight::onCloudScrollXToggled(LLUICtrl* ctrl)
  835. {
  836. deactivateAnimator();
  838. LLCheckBoxCtrl* cbCtrl = static_cast<LLCheckBoxCtrl*>(ctrl);
  840. bool lock = cbCtrl->get();
  841. LLWLParamManager::instance()->mCurParams.setEnableCloudScrollX(!lock);
  843. LLSliderCtrl* sldr = getChild<LLSliderCtrl>( 
  844. "WLCloudScrollX");
  846. if(cbCtrl->get()) 
  847. {
  848. sldr->setEnabled(false);
  849. } 
  850. else 
  851. {
  852. sldr->setEnabled(true);
  853. }
  855. }
  857. void LLFloaterWindLight::onCloudScrollYToggled(LLUICtrl* ctrl)
  858. {
  859. deactivateAnimator();
  861. LLCheckBoxCtrl* cbCtrl = static_cast<LLCheckBoxCtrl*>(ctrl);
  862. bool lock = cbCtrl->get();
  863. LLWLParamManager::instance()->mCurParams.setEnableCloudScrollY(!lock);
  865. LLSliderCtrl* sldr = getChild<LLSliderCtrl>( 
  866. "WLCloudScrollY");
  868. if(cbCtrl->get()) 
  869. {
  870. sldr->setEnabled(false);
  871. } 
  872. else 
  873. {
  874. sldr->setEnabled(true);
  875. }
  876. }
  878. void LLFloaterWindLight::deactivateAnimator()
  879. {
  880. LLWLParamManager::instance()->mAnimator.mIsRunning = false;
  881. LLWLParamManager::instance()->mAnimator.mUseLindenTime = false;
  882. }