From e045d212d35354d679c2d2e05c6d4689f9f8ac95 Mon Sep 17 00:00:00 2001 From: "Nyx (Neal Orman)" Date: Mon, 27 Sep 2010 22:56:08 -0400 Subject: STORM-1126 WIP Windlight Estate Settings port from 1.23: first pass at merging in windlight estate settings to viewer-dev codebase. not built, not tested. Probably needs a bunch of fixes to be able to be integrated. (resubmitted by Vadim ProductEngine) --- indra/newview/llenvmanager.cpp | 474 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 474 insertions(+) create mode 100644 indra/newview/llenvmanager.cpp (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp new file mode 100644 index 0000000000..f551aa6c8a --- /dev/null +++ b/indra/newview/llenvmanager.cpp @@ -0,0 +1,474 @@ +/** + * @file llenvmanager.cpp + * @brief Implementation of classes managing WindLight and water settings. + * + * $LicenseInfo:firstyear=2009&license=viewergpl$ + * + * Copyright (c) 2009, Linden Research, Inc. + * + * Second Life Viewer Source Code + * The source code in this file ("Source Code") is provided by Linden Lab + * to you under the terms of the GNU General Public License, version 2.0 + * ("GPL"), unless you have obtained a separate licensing agreement + * ("Other License"), formally executed by you and Linden Lab. Terms of + * the GPL can be found in doc/GPL-license.txt in this distribution, or + * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 + * + * There are special exceptions to the terms and conditions of the GPL as + * it is applied to this Source Code. View the full text of the exception + * in the file doc/FLOSS-exception.txt in this software distribution, or + * online at + * http://secondlifegrid.net/programs/open_source/licensing/flossexception + * + * By copying, modifying or distributing this software, you acknowledge + * that you have read and understood your obligations described above, + * and agree to abide by those obligations. + * + * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO + * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, + * COMPLETENESS OR PERFORMANCE. + * $/LicenseInfo$ + */ + +#include "llviewerprecompiledheaders.h" + +#include "llenvmanager.h" + +#include "llagent.h" +#include "llviewerregion.h" + +#include "llfloaterwindlight.h" +#include "llfloaterwater.h" +#include "llfloaterenvsettings.h" +#include "llwlparammanager.h" +#include "llwaterparammanager.h" +#include "llfloaterregioninfo.h" +#include "llwindlightscrubbers.h" +#include "llwlhandlers.h" + +extern LLControlGroup gSavedSettings; + +/*virtual*/ void LLEnvManager::initSingleton() +{ + mOrigSettingStore[LLEnvKey::SCOPE_LOCAL] = lindenDefaults(); + mCurNormalScope = (gSavedSettings.getBOOL("UseEnvironmentFromRegion") ? LLEnvKey::SCOPE_REGION : LLEnvKey::SCOPE_LOCAL); + mInterpNextChangeMessage = true; + mPendingOutgoingMessage = false; + mIsEditing = false; +} + +/******* + * Region Changes + *******/ + +void LLEnvManager::notifyLogin() +{ + changedRegion(false); +} +void LLEnvManager::notifyCrossing() +{ + changedRegion(true); +} +void LLEnvManager::notifyTP() +{ + changedRegion(false); +} +void LLEnvManager::changedRegion(bool interp) +{ + mInterpNextChangeMessage = interp; + mPendingOutgoingMessage = false; + + LLFloaterEnvSettings::instance()->close(); + + resetInternalsToDefault(LLEnvKey::SCOPE_REGION); + + maybeClearEditingScope(LLEnvKey::SCOPE_REGION, true, false); +} + +/******* + * Editing settings / UI mode + *******/ + +void LLEnvManager::startEditingScope(LLEnvKey::EScope scope) +{ + if (mIsEditing) + { + LL_WARNS("Windlight") << "Tried to start editing windlight settings while already editing some settings (possibly others)! Ignoring..." << LL_ENDL; + return; + } + if (!canEdit(scope)) + { + LL_WARNS("Windlight") << "Tried to start editing windlight settings while not allowed to! Ignoring..." << LL_ENDL; + return; + } + + mIsEditing = true; + mCurEditingScope = scope; + + // show scope being edited + loadSettingsIntoManagers(scope, false); + + switch (scope) + { + case LLEnvKey::SCOPE_LOCAL: + // not implemented here (yet) + return; + case LLEnvKey::SCOPE_REGION: + LLPanelRegionTerrainInfo::instance()->setCommitControls(true); + break; + default: + return; + } +} + +void LLEnvManager::maybeClearEditingScope(LLEnvKey::EScope scope, bool user_initiated, bool was_commit) +{ + if (mIsEditing && mCurEditingScope == scope) + { + maybeClearEditingScope(user_initiated, was_commit); // handles UI, updating managers, etc. + } +} + +void LLEnvManager::maybeClearEditingScope(bool user_initiated, bool was_commit) +{ + bool clear_now = true; + if (mIsEditing && !was_commit) + { + if(user_initiated) + { + LLSD args; + args["SCOPE"] = getScopeString(mCurEditingScope); + LLNotifications::instance().add("EnvEditUnsavedChangesCancel", args, LLSD(), + boost::bind(&LLEnvManager::clearEditingScope, this, _1, _2)); + clear_now = false; + } + else + { + LLNotifications::instance().add("EnvEditExternalCancel", LLSD()); + } + } + + if(clear_now) + { + clearEditingScope(LLSD(), LLSD()); + } +} + +void LLEnvManager::clearEditingScope(const LLSD& notification, const LLSD& response) +{ + if(notification.isDefined() && response.isDefined() && LLNotification::getSelectedOption(notification, response) != 0) + { + // *TODO: select terrain panel here + mIsEditing = false; + LLFloaterRegionInfo::showInstance(); + return; + } + + mIsEditing = false; + + updateUIFromEditability(); + LLPanelRegionTerrainInfo::instance()->cancelChanges(); + + loadSettingsIntoManagers(mCurNormalScope, true); +} + +void LLEnvManager::updateUIFromEditability() +{ + // *TODO When the checkbox from LLFloaterEnvSettings is moved elsewhere, opening the local environment settings window should auto-display local settings + // Currently, disable all editing to ensure region settings are hidden from those that can't edit them (to preserve possibility of future tradable assets) + // Remove "!gSavedSettings.getBOOL(...)" when the desired behavior is implemented + LLFloaterEnvSettings::instance()->setControlsEnabled(canEdit(LLEnvKey::SCOPE_LOCAL) && !gSavedSettings.getBOOL("UseEnvironmentFromRegion")); + LLPanelRegionTerrainInfo::instance()->setEnvControls(canEdit(LLEnvKey::SCOPE_REGION)); + // enable estate UI iff canEdit(LLEnvKey::SCOPE_ESTATE), etc. +} + +bool LLEnvManager::regionCapable() +{ + return !gAgent.getRegion()->getCapability("EnvironmentSettings").empty(); +} + +const std::string LLEnvManager::getScopeString(LLEnvKey::EScope scope) +{ + switch(scope) + { + case LLEnvKey::SCOPE_LOCAL: + return LLTrans::getString("LocalSettings"); + case LLEnvKey::SCOPE_REGION: + return LLTrans::getString("RegionSettings"); + default: + return " (?)"; + } +} + +bool LLEnvManager::canEdit(LLEnvKey::EScope scope) +{ + // can't edit while a message is being sent or if already editing + if (mPendingOutgoingMessage || mIsEditing) + { + return false; + } + + // check permissions and caps + switch (scope) + { + case LLEnvKey::SCOPE_LOCAL: + return true; // always permitted to edit local + case LLEnvKey::SCOPE_REGION: + bool owner_or_god_or_manager; + { + LLViewerRegion* region = gAgent.getRegion(); + if (NULL == region || region->getCapability("EnvironmentSettings").empty()) + { + // not a windlight-aware region + return false; + } + owner_or_god_or_manager = gAgent.isGodlike() + || (region && (region->getOwner() == gAgent.getID())) + || (region && region->isEstateManager()); + } + return owner_or_god_or_manager; + default: + return false; + } +} + +/******* + * Incoming Messaging + *******/ + +void LLEnvManager::refreshFromStorage(LLEnvKey::EScope scope) +{ + switch (scope) + { + case LLEnvKey::SCOPE_LOCAL: + break; + case LLEnvKey::SCOPE_REGION: + if (!LLEnvironmentRequestResponder::initiateRequest()) + { + // don't have a cap for this, presume invalid response + processIncomingMessage(LLSD(), scope); + } + break; + default: + processIncomingMessage(LLSD(), scope); + break; + } +} + +bool LLEnvManager::processIncomingMessage(const LLSD& unvalidated_content, const LLEnvKey::EScope scope) +{ + if (scope != LLEnvKey::SCOPE_REGION) + { + return false; + } + + // Start out with defaults + resetInternalsToDefault(scope); + updateUIFromEditability(); + + // Validate + std::set empty_set; + LLWLPacketScrubber scrubber(scope, empty_set); + LLSD windlight_llsd = scrubber.scrub(unvalidated_content); + + bool valid = windlight_llsd.isDefined(); // successful scrub + + mLastReceivedID = unvalidated_content[0]["messageID"].asUUID(); // if the message was valid, grab the UUID from it and save it for next outbound update message + + if (valid) + { + F32 sun_hour = LLPanelRegionTerrainInfo::instance()->getSunHour(); // this slider is kept up to date + LLWLParamManager::getInstance()->addAllSkies(scope, windlight_llsd[2]); + LLEnvironmentSettings newSettings(windlight_llsd[1], windlight_llsd[2], windlight_llsd[3], sun_hour); + mOrigSettingStore[scope] = newSettings; + } + else + { + LL_WARNS("Windlight Sync") << "Failed to parse windlight settings!" << LL_ENDL; + // presume defaults (already reset above) + } + + maybeClearEditingScope(scope, false, false); + + // refresh display with new settings, if applicable + if (mCurNormalScope == scope && !mIsEditing) // if mIsEditing still, must be editing some other scope, so don't load + { + loadSettingsIntoManagers(scope, mInterpNextChangeMessage); + } + + mInterpNextChangeMessage = true; // reset flag + + return valid; +} + + +/******* + * Outgoing Messaging + *******/ + +void LLEnvManager::commitSettings(LLEnvKey::EScope scope) +{ + bool success = true; + switch (scope) + { + case (LLEnvKey::SCOPE_LOCAL): + // not implemented - LLWLParamManager and LLWaterParamManager currently manage local storage themselves + break; + case (LLEnvKey::SCOPE_REGION): + mPendingOutgoingMessage = true; + LLSD metadata(LLSD::emptyMap()); + metadata["regionID"] = gAgent.getRegion()->getRegionID(); + metadata["messageID"] = mLastReceivedID; // add last received update ID to outbound message so simulator can handle concurrent updates + + saveSettingsFromManagers(scope); // save current settings into settings store before grabbing from settings store and sending + success = LLEnvironmentApplyResponder::initiateRequest(makePacket(LLEnvKey::SCOPE_REGION, metadata)); + if(success) + { + // while waiting for the return message, render old settings + // (as of Aug 09, we should get an updated RegionInfo packet, which triggers a re-request of Windlight data, which causes us to show new settings) + loadSettingsIntoManagers(LLEnvKey::SCOPE_REGION, true); + } + break; + } + + if(success) + { + // with mPendingOutgoingMessage = true, nothing is editable + updateUIFromEditability(); + maybeClearEditingScope(true, true); + } + else + { + mPendingOutgoingMessage = false; + } +} + +LLSD LLEnvManager::makePacket(LLEnvKey::EScope scope, const LLSD& metadata) +{ + return mOrigSettingStore[scope].makePacket(metadata); +} + +void LLEnvManager::commitSettingsFinished(LLEnvKey::EScope scope) +{ + mPendingOutgoingMessage = false; + + updateUIFromEditability(); +} + +/******* + * Loading defaults + *******/ + +void LLEnvManager::resetInternalsToDefault(LLEnvKey::EScope scope) +{ + if (LLEnvKey::SCOPE_LOCAL != scope) + { + LLWLParamManager::getInstance()->clearParamSetsOfScope(scope); + } + + mOrigSettingStore[scope] = lindenDefaults(); + LLWLParamManager::getInstance()->mAnimator.setTimeType(LLWLAnimator::TIME_LINDEN); +} + +const LLEnvironmentSettings& LLEnvManager::lindenDefaults() +{ + static bool loaded = false; + static LLEnvironmentSettings defSettings; + + if (!loaded) + { + LLWaterParamSet defaultWater; + LLWaterParamManager::instance().getParamSet("default", defaultWater); + + // *TODO save default skies (remove hack in LLWLDayCycle::loadDayCycle when this is done) + + defSettings.saveParams( + LLWLDayCycle::loadCycleDataFromFile("default.xml"), // frames will refer to local presets, which is okay + LLSD(LLSD::emptyMap()), // should never lose the default sky presets (read-only) + defaultWater.getAll(), + 0.0); + + loaded = true; + } + + return defSettings; +} + +/******* + * Manipulation of Param Managers + *******/ + +void LLEnvManager::loadSettingsIntoManagers(LLEnvKey::EScope scope, bool interpolate) +{ + LLEnvironmentSettings settings = mOrigSettingStore[scope]; + + if(interpolate) + { + LLWLParamManager::getInstance()->mAnimator.startInterpolation(settings.getWaterParams()); + } + + LLWLParamManager::getInstance()->addAllSkies(scope, settings.getSkyMap()); + LLWLParamManager::getInstance()->mDay.loadDayCycle(settings.getWLDayCycle(), scope); + LLWLParamManager::getInstance()->resetAnimator(settings.getDayTime(), true); + + LLWaterParamManager::getInstance()->mCurParams.setAll(settings.getWaterParams()); +} + +void LLEnvManager::saveSettingsFromManagers(LLEnvKey::EScope scope) +{ + switch (scope) + { + case LLEnvKey::SCOPE_LOCAL: + mOrigSettingStore[scope].saveParams( + LLWLParamManager::getInstance()->mDay.asLLSD(), + LLSD(LLSD::emptyMap()), // never overwrite + LLWaterParamManager::getInstance()->mCurParams.getAll(), + LLWLParamManager::getInstance()->mAnimator.mDayTime); + break; + case LLEnvKey::SCOPE_REGION: + { + // ensure only referenced region-scope skies are saved, resolve naming collisions, etc. + std::map final_references = LLWLParamManager::getInstance()->finalizeFromDayCycle(scope); + LLSD referenced_skies = LLWLParamManager::getInstance()->createSkyMap(final_references); + mOrigSettingStore[scope].saveParams( + LLWLParamManager::getInstance()->mDay.asLLSD(), + referenced_skies, + LLWaterParamManager::getInstance()->mCurParams.getAll(), + LLWLParamManager::getInstance()->mAnimator.mDayTime); + } + break; + default: + return; + } +} + +/******* + * Setting desired display level + *******/ + +void LLEnvManager::setNormallyDisplayedScope(LLEnvKey::EScope new_scope) +{ + // temp, just save the scope directly as a value in the future when there's more than two + bool want_region = (LLEnvKey::SCOPE_REGION == new_scope); + gSavedSettings.setBOOL("UseEnvironmentFromRegion", want_region); + + if (mCurNormalScope != new_scope) + { + mCurNormalScope = new_scope; + notifyOptInChange(); + } +} + +void LLEnvManager::notifyOptInChange() +{ + bool opt_in = gSavedSettings.getBOOL("UseEnvironmentFromRegion"); + + // Save local settings if switching to region + if(opt_in) + { + LL_INFOS("Windlight") << "Saving currently-displayed settings as current local settings..." << LL_ENDL; + saveSettingsFromManagers(LLEnvKey::SCOPE_LOCAL); + } + + maybeClearEditingScope(true, false); +} -- cgit v1.2.3 From 2fb337bc12984f9abecfbc7f3918c372a7b5ac6c Mon Sep 17 00:00:00 2001 From: "Nyx (Neal Orman)" Date: Thu, 30 Sep 2010 23:21:23 -0400 Subject: STORM-1126 WIP Windlight Estate Settings port from 1.23: second pass at getting windlight ported to V2. Lots of cleanup in the floater classes. Not sure every decision was correct but it compiles now. Doesn't link yet. (resubmitted by Vadim ProductEngine) --- indra/newview/llenvmanager.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index f551aa6c8a..a257e4ea24 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -37,6 +37,7 @@ #include "llagent.h" #include "llviewerregion.h" +#include "llfloaterreg.h" #include "llfloaterwindlight.h" #include "llfloaterwater.h" #include "llfloaterenvsettings.h" @@ -45,6 +46,7 @@ #include "llfloaterregioninfo.h" #include "llwindlightscrubbers.h" #include "llwlhandlers.h" +#include "llnotifications.h" extern LLControlGroup gSavedSettings; @@ -78,7 +80,7 @@ void LLEnvManager::changedRegion(bool interp) mInterpNextChangeMessage = interp; mPendingOutgoingMessage = false; - LLFloaterEnvSettings::instance()->close(); + LLFloaterEnvSettings::instance()->closeFloater(); resetInternalsToDefault(LLEnvKey::SCOPE_REGION); @@ -144,7 +146,7 @@ void LLEnvManager::maybeClearEditingScope(bool user_initiated, bool was_commit) } else { - LLNotifications::instance().add("EnvEditExternalCancel", LLSD()); + LLNotifications::instance().add("EnvEditExternalCancel", LLSD(), LLSD()); } } @@ -160,7 +162,7 @@ void LLEnvManager::clearEditingScope(const LLSD& notification, const LLSD& respo { // *TODO: select terrain panel here mIsEditing = false; - LLFloaterRegionInfo::showInstance(); + LLFloaterReg::showTypedInstance("regioninfo"); return; } -- cgit v1.2.3 From 6bb02e0e260df2d00ab53376cf15af5e7e2fd12f Mon Sep 17 00:00:00 2001 From: Celierra Darling Date: Mon, 10 Jan 2011 15:06:30 -0500 Subject: STORM-1126 WIP Windlight Estate Settings port from 1.23: Various changes to allow compilation (resubmitted by Vadim ProductEngine) --- indra/newview/llenvmanager.cpp | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index a257e4ea24..daf3f90234 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -44,7 +44,7 @@ #include "llwlparammanager.h" #include "llwaterparammanager.h" #include "llfloaterregioninfo.h" -#include "llwindlightscrubbers.h" +//#include "llwindlightscrubbers.h" // *HACK commented out since this code isn't released (yet) #include "llwlhandlers.h" #include "llnotifications.h" @@ -269,11 +269,16 @@ bool LLEnvManager::processIncomingMessage(const LLSD& unvalidated_content, const updateUIFromEditability(); // Validate - std::set empty_set; - LLWLPacketScrubber scrubber(scope, empty_set); - LLSD windlight_llsd = scrubber.scrub(unvalidated_content); + //std::set empty_set; + //LLWLPacketScrubber scrubber(scope, empty_set); + //LLSD windlight_llsd = scrubber.scrub(unvalidated_content); - bool valid = windlight_llsd.isDefined(); // successful scrub + //bool valid = windlight_llsd.isDefined(); // successful scrub + + // *HACK - Don't have the validator, so just use content without validating. Should validate here for third-party grids. + LLSD windlight_llsd(unvalidated_content); + bool valid = true; + // end HACK mLastReceivedID = unvalidated_content[0]["messageID"].asUUID(); // if the message was valid, grab the UUID from it and save it for next outbound update message -- cgit v1.2.3 From 758fdbfe125d75bd2253a69337eab7fec7406ecf Mon Sep 17 00:00:00 2001 From: "tiggs@lindenlab.com" Date: Wed, 23 Feb 2011 17:44:18 -0500 Subject: STORM-1126 WIP Windlight Estate Settings port from 1.23: baseline: read only windlight works (resubmitted by Vadim ProductEngine) --- indra/newview/llenvmanager.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index daf3f90234..8e5889e74b 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -80,7 +80,7 @@ void LLEnvManager::changedRegion(bool interp) mInterpNextChangeMessage = interp; mPendingOutgoingMessage = false; - LLFloaterEnvSettings::instance()->closeFloater(); + // TIGGGS LLFloaterEnvSettings::instance()->closeFloater(); resetInternalsToDefault(LLEnvKey::SCOPE_REGION); @@ -179,8 +179,8 @@ void LLEnvManager::updateUIFromEditability() // *TODO When the checkbox from LLFloaterEnvSettings is moved elsewhere, opening the local environment settings window should auto-display local settings // Currently, disable all editing to ensure region settings are hidden from those that can't edit them (to preserve possibility of future tradable assets) // Remove "!gSavedSettings.getBOOL(...)" when the desired behavior is implemented - LLFloaterEnvSettings::instance()->setControlsEnabled(canEdit(LLEnvKey::SCOPE_LOCAL) && !gSavedSettings.getBOOL("UseEnvironmentFromRegion")); - LLPanelRegionTerrainInfo::instance()->setEnvControls(canEdit(LLEnvKey::SCOPE_REGION)); +// LLFloaterEnvSettings::instance()->setControlsEnabled(canEdit(LLEnvKey::SCOPE_LOCAL) && !gSavedSettings.getBOOL("UseEnvironmentFromRegion")); +// LLPanelRegionTerrainInfo::instance()->setEnvControls(canEdit(LLEnvKey::SCOPE_REGION)); // enable estate UI iff canEdit(LLEnvKey::SCOPE_ESTATE), etc. } -- cgit v1.2.3 From 79fb8e2ec26dc2c5a42ef1ee48ebaaa39183c67b Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Thu, 31 Mar 2011 18:24:01 +0300 Subject: STORM-1126 WIP Windlight Estate Settings integration: pass 4 Changes: * Fixed incorrect way to pass parameters to notifications. * Fixed crashes in the Advanced Sky floater and the Region Terrain panel. * Fixed initialization and multiple instantiation of the Day Cycle floater (that might lead to incorrect behavior). * Fixed and re-enabled committing env. settings changes to region. * Fixed day cycle and sky settings being sent as empty arrays and therefore not passing validation on server. It is now possible to change region environment settings. * Added debug messages. --- indra/newview/llenvmanager.cpp | 26 +++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 8e5889e74b..d4e60ffd94 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -80,7 +80,7 @@ void LLEnvManager::changedRegion(bool interp) mInterpNextChangeMessage = interp; mPendingOutgoingMessage = false; - // TIGGGS LLFloaterEnvSettings::instance()->closeFloater(); + LLFloaterReg::hideInstance("env_settings"); resetInternalsToDefault(LLEnvKey::SCOPE_REGION); @@ -93,6 +93,8 @@ void LLEnvManager::changedRegion(bool interp) void LLEnvManager::startEditingScope(LLEnvKey::EScope scope) { + LL_DEBUGS("Windlight") << "Starting editing scope " << scope << LL_ENDL; + if (mIsEditing) { LL_WARNS("Windlight") << "Tried to start editing windlight settings while already editing some settings (possibly others)! Ignoring..." << LL_ENDL; @@ -158,6 +160,8 @@ void LLEnvManager::maybeClearEditingScope(bool user_initiated, bool was_commit) void LLEnvManager::clearEditingScope(const LLSD& notification, const LLSD& response) { + LL_DEBUGS("Windlight") << "Clearing editing scope " << mCurNormalScope << LL_ENDL; + if(notification.isDefined() && response.isDefined() && LLNotification::getSelectedOption(notification, response) != 0) { // *TODO: select terrain panel here @@ -284,6 +288,8 @@ bool LLEnvManager::processIncomingMessage(const LLSD& unvalidated_content, const if (valid) { + LL_DEBUGS("Windlight Sync") << "windlight_llsd: " << windlight_llsd << LL_ENDL; + F32 sun_hour = LLPanelRegionTerrainInfo::instance()->getSunHour(); // this slider is kept up to date LLWLParamManager::getInstance()->addAllSkies(scope, windlight_llsd[2]); LLEnvironmentSettings newSettings(windlight_llsd[1], windlight_llsd[2], windlight_llsd[3], sun_hour); @@ -302,6 +308,10 @@ bool LLEnvManager::processIncomingMessage(const LLSD& unvalidated_content, const { loadSettingsIntoManagers(scope, mInterpNextChangeMessage); } + else + { + LL_DEBUGS("Windlight Sync") << "Not loading settings (mCurNormalScope=" << mCurNormalScope << ", scope=" << scope << ", mIsEditing=" << mIsEditing << ")" << LL_ENDL; + } mInterpNextChangeMessage = true; // reset flag @@ -315,6 +325,8 @@ bool LLEnvManager::processIncomingMessage(const LLSD& unvalidated_content, const void LLEnvManager::commitSettings(LLEnvKey::EScope scope) { + LL_DEBUGS("Windlight Sync") << "commitSettings(scope = " << scope << ")" << LL_ENDL; + bool success = true; switch (scope) { @@ -407,6 +419,8 @@ const LLEnvironmentSettings& LLEnvManager::lindenDefaults() void LLEnvManager::loadSettingsIntoManagers(LLEnvKey::EScope scope, bool interpolate) { + LL_DEBUGS("Windlight Sync") << "Loading settings (scope = " << scope << ")" << LL_ENDL; + LLEnvironmentSettings settings = mOrigSettingStore[scope]; if(interpolate) @@ -423,6 +437,7 @@ void LLEnvManager::loadSettingsIntoManagers(LLEnvKey::EScope scope, bool interpo void LLEnvManager::saveSettingsFromManagers(LLEnvKey::EScope scope) { + LL_DEBUGS("Windlight Sync") << "Saving settings (scope = " << scope << ")" << LL_ENDL; switch (scope) { case LLEnvKey::SCOPE_LOCAL: @@ -437,6 +452,9 @@ void LLEnvManager::saveSettingsFromManagers(LLEnvKey::EScope scope) // ensure only referenced region-scope skies are saved, resolve naming collisions, etc. std::map final_references = LLWLParamManager::getInstance()->finalizeFromDayCycle(scope); LLSD referenced_skies = LLWLParamManager::getInstance()->createSkyMap(final_references); + + LL_DEBUGS("Windlight Sync") << "Dumping referenced skies (" << final_references.size() << ") to LLSD: " << referenced_skies << LL_ENDL; + mOrigSettingStore[scope].saveParams( LLWLParamManager::getInstance()->mDay.asLLSD(), referenced_skies, @@ -461,11 +479,17 @@ void LLEnvManager::setNormallyDisplayedScope(LLEnvKey::EScope new_scope) if (mCurNormalScope != new_scope) { + LL_INFOS("Windlight") << "Switching to scope " << new_scope << LL_ENDL; mCurNormalScope = new_scope; notifyOptInChange(); } } +LLEnvKey::EScope LLEnvManager::getNormallyDisplayedScope() const +{ + return mCurNormalScope; +} + void LLEnvManager::notifyOptInChange() { bool opt_in = gSavedSettings.getBOOL("UseEnvironmentFromRegion"); -- cgit v1.2.3 From 7419abc12ba07380593fa3c0571155b248b8c8a6 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Thu, 31 Mar 2011 18:24:01 +0300 Subject: STORM-1126 WIP Windlight Estate Settings integration: pass 5 * Added "Apply Local to Region" button to the region terrain setttings panel. * Fixed previewing presets via a combomox in the Advanced Sky Editor floater. --- indra/newview/llenvmanager.cpp | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index d4e60ffd94..010ecc267b 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -374,6 +374,12 @@ void LLEnvManager::commitSettingsFinished(LLEnvKey::EScope scope) updateUIFromEditability(); } +void LLEnvManager::applyLocalSettingsToRegion() +{ + // Immediately apply current environment settings to region. + LLEnvManager::instance().commitSettings(LLEnvKey::SCOPE_REGION); +} + /******* * Loading defaults *******/ -- cgit v1.2.3 From 38f87d0e21cfb6807e262e0289e1f6b08904a4e7 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Thu, 31 Mar 2011 18:24:01 +0300 Subject: STORM-1126 WIP Windlight Estate Settings integration: pass 6 * Made it possible to update a region sky preset with the Save button. * Fixed resetting day cycle when you start editing region environment settings. * Fixed: if you press "Cancel Changes" in the region envitonment settings and then choose to resume editing in the confirmation dialog, you won't be able to cancel your changes later. --- indra/newview/llenvmanager.cpp | 31 +++++++++++++++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 010ecc267b..9300161837 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -109,6 +109,12 @@ void LLEnvManager::startEditingScope(LLEnvKey::EScope scope) mIsEditing = true; mCurEditingScope = scope; + // Back up local settings so that we can switch back to them later. + if (scope != LLEnvKey::SCOPE_LOCAL) + { + backUpLocalSettingsIfNeeded(); + } + // show scope being edited loadSettingsIntoManagers(scope, false); @@ -160,16 +166,17 @@ void LLEnvManager::maybeClearEditingScope(bool user_initiated, bool was_commit) void LLEnvManager::clearEditingScope(const LLSD& notification, const LLSD& response) { - LL_DEBUGS("Windlight") << "Clearing editing scope " << mCurNormalScope << LL_ENDL; - if(notification.isDefined() && response.isDefined() && LLNotification::getSelectedOption(notification, response) != 0) { +#if 0 // *TODO: select terrain panel here mIsEditing = false; LLFloaterReg::showTypedInstance("regioninfo"); +#endif return; } + LL_DEBUGS("Windlight") << "Clearing editing scope " << mCurNormalScope << LL_ENDL; mIsEditing = false; updateUIFromEditability(); @@ -244,6 +251,12 @@ bool LLEnvManager::canEdit(LLEnvKey::EScope scope) void LLEnvManager::refreshFromStorage(LLEnvKey::EScope scope) { + // Back up local env. settings so that we can switch to them later. + if (scope != LLEnvKey::SCOPE_LOCAL) + { + backUpLocalSettingsIfNeeded(); + } + switch (scope) { case LLEnvKey::SCOPE_LOCAL: @@ -473,6 +486,20 @@ void LLEnvManager::saveSettingsFromManagers(LLEnvKey::EScope scope) } } +void LLEnvManager::backUpLocalSettingsIfNeeded() +{ + // *HACK: Back up local env. settings so that we can switch to them later. + // Otherwise local day cycle is likely to be reset. + static bool sSavedLocalSettings = false; + + if (!sSavedLocalSettings) + { + LL_DEBUGS("Windlight") << "Backing up local environment settings" << LL_ENDL; + saveSettingsFromManagers(LLEnvKey::SCOPE_LOCAL); + sSavedLocalSettings = true; + } +} + /******* * Setting desired display level *******/ -- cgit v1.2.3 From 4b5eeb34601ac642194e245ef3928a3b9e56d3b8 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Thu, 7 Apr 2011 06:26:42 +0300 Subject: STORM-1142 ADDITIONAL_COMMIT Debugging improvements. --- indra/newview/llenvmanager.cpp | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 9300161837..b69586e88e 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -176,7 +176,6 @@ void LLEnvManager::clearEditingScope(const LLSD& notification, const LLSD& respo return; } - LL_DEBUGS("Windlight") << "Clearing editing scope " << mCurNormalScope << LL_ENDL; mIsEditing = false; updateUIFromEditability(); @@ -536,3 +535,14 @@ void LLEnvManager::notifyOptInChange() maybeClearEditingScope(true, false); } + +void LLEnvManager::dumpScopes() +{ + LLSD scope_dump; + + scope_dump = makePacket(LLEnvKey::SCOPE_LOCAL, LLSD()); + LL_DEBUGS("Windlight") << "Local scope:" << scope_dump << LL_ENDL; + + scope_dump = makePacket(LLEnvKey::SCOPE_REGION, LLSD()); + LL_DEBUGS("Windlight") << "Region scope:" << scope_dump << LL_ENDL; +} -- cgit v1.2.3 From 19f356202a9516664c1cacb9b50e9b6e1e072375 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Tue, 12 Apr 2011 22:07:59 +0300 Subject: STORM-1143 FIXED Server sometimes said region wasn't capable of storing environment settings. Reason: We tried to check whether the region supports environment settings without making sure that we've actually recieved region capabilities, so the check sometimes failed. Fix: Defer check for the "EnvironmentSettings" capability until we've received the region capabilities. --- indra/newview/llenvmanager.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index b69586e88e..687f9974b1 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -261,7 +261,7 @@ void LLEnvManager::refreshFromStorage(LLEnvKey::EScope scope) case LLEnvKey::SCOPE_LOCAL: break; case LLEnvKey::SCOPE_REGION: - if (!LLEnvironmentRequestResponder::initiateRequest()) + if (!LLEnvironmentRequest::initiate()) { // don't have a cap for this, presume invalid response processIncomingMessage(LLSD(), scope); @@ -297,11 +297,11 @@ bool LLEnvManager::processIncomingMessage(const LLSD& unvalidated_content, const // end HACK mLastReceivedID = unvalidated_content[0]["messageID"].asUUID(); // if the message was valid, grab the UUID from it and save it for next outbound update message + LL_DEBUGS("Windlight Sync") << "mLastReceivedID: " << mLastReceivedID << LL_ENDL; + LL_DEBUGS("Windlight Sync") << "windlight_llsd: " << windlight_llsd << LL_ENDL; if (valid) { - LL_DEBUGS("Windlight Sync") << "windlight_llsd: " << windlight_llsd << LL_ENDL; - F32 sun_hour = LLPanelRegionTerrainInfo::instance()->getSunHour(); // this slider is kept up to date LLWLParamManager::getInstance()->addAllSkies(scope, windlight_llsd[2]); LLEnvironmentSettings newSettings(windlight_llsd[1], windlight_llsd[2], windlight_llsd[3], sun_hour); -- cgit v1.2.3 From fc71ae3e69e78a2e34832418c6c120c9e633bbb6 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Mon, 18 Apr 2011 22:13:49 +0300 Subject: STORM-1180 FIX Temporarily disabled region environment controls. Besides, adding a workaround for a crash on exit I've experienced. --- indra/newview/llenvmanager.cpp | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 687f9974b1..c855d8597c 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -302,7 +302,18 @@ bool LLEnvManager::processIncomingMessage(const LLSD& unvalidated_content, const if (valid) { - F32 sun_hour = LLPanelRegionTerrainInfo::instance()->getSunHour(); // this slider is kept up to date + F32 sun_hour = 0; + LLPanelRegionTerrainInfo* terrain_panel = LLPanelRegionTerrainInfo::instance(); + + if (terrain_panel) + { + sun_hour = terrain_panel->getSunHour(); // this slider is kept up to date + } + else + { + llwarns << "Cannot instantiate the terrain panel (exiting?)" << llendl; + } + LLWLParamManager::getInstance()->addAllSkies(scope, windlight_llsd[2]); LLEnvironmentSettings newSettings(windlight_llsd[1], windlight_llsd[2], windlight_llsd[3], sun_hour); mOrigSettingStore[scope] = newSettings; -- cgit v1.2.3 From cccca566bd2365c88cca819729c5432af9dfa52f Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Mon, 16 May 2011 17:17:01 +0300 Subject: STORM-1245 WIP Reimplementing management of local presets according to the new spec. User environment preferences are now persistent. TODO: Implement applying region env. settings. --- indra/newview/llenvmanager.cpp | 231 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 231 insertions(+) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index c855d8597c..49bbf1a77c 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -52,6 +52,8 @@ extern LLControlGroup gSavedSettings; /*virtual*/ void LLEnvManager::initSingleton() { + LL_DEBUGS("Windlight") << "Initializing LLEnvManager" << LL_ENDL; + mOrigSettingStore[LLEnvKey::SCOPE_LOCAL] = lindenDefaults(); mCurNormalScope = (gSavedSettings.getBOOL("UseEnvironmentFromRegion") ? LLEnvKey::SCOPE_REGION : LLEnvKey::SCOPE_LOCAL); mInterpNextChangeMessage = true; @@ -557,3 +559,232 @@ void LLEnvManager::dumpScopes() scope_dump = makePacket(LLEnvKey::SCOPE_REGION, LLSD()); LL_DEBUGS("Windlight") << "Region scope:" << scope_dump << LL_ENDL; } + + +//============================================================================= + +std::string LLEnvPrefs::getWaterPresetName() const +{ + if (mWaterPresetName.empty()) + { + llwarns << "Water preset name is empty" << llendl; + } + + return mWaterPresetName; +} + +std::string LLEnvPrefs::getSkyPresetName() const +{ + if (mSkyPresetName.empty()) + { + llwarns << "Sky preset name is empty" << llendl; + } + + return mSkyPresetName; +} + +std::string LLEnvPrefs::getDayCycleName() const +{ + if (mDayCycleName.empty()) + { + llwarns << "Day cycle name is empty" << llendl; + } + + return mDayCycleName; +} + +void LLEnvPrefs::setUseDefaults(bool val) +{ + mUseDefaults = val; +} + +void LLEnvPrefs::setUseWaterPreset(const std::string& name) +{ + setUseDefaults(false); + mWaterPresetName = name; +} + +void LLEnvPrefs::setUseSkyPreset(const std::string& name) +{ + setUseDefaults(false); + mUseDayCycle = false; + mSkyPresetName = name; +} + +void LLEnvPrefs::setUseDayCycle(const std::string& name) +{ + setUseDefaults(false); + mUseDayCycle = true; + mDayCycleName = name; +} + +//============================================================================= +LLEnvManagerNew::LLEnvManagerNew() +{ + mInterpNextChangeMessage = true; + + // Set default environment settings. + mUserPrefs.mUseDefaults = true; + mUserPrefs.mUseDayCycle = true; + mUserPrefs.mWaterPresetName = "Default"; + mUserPrefs.mSkyPresetName = "Default"; + mUserPrefs.mDayCycleName = "Default"; +} + +bool LLEnvManagerNew::getUseRegionSettings() const +{ + return mUserPrefs.getUseDefaults(); +} + +bool LLEnvManagerNew::getUseDayCycle() const +{ + return mUserPrefs.getUseDayCycle(); +} + +bool LLEnvManagerNew::getUseFixedSky() const +{ + return mUserPrefs.getUseFixedSky(); +} + +std::string LLEnvManagerNew::getWaterPresetName() const +{ + return mUserPrefs.getWaterPresetName(); +} + +std::string LLEnvManagerNew::getSkyPresetName() const +{ + return mUserPrefs.getSkyPresetName(); +} + +std::string LLEnvManagerNew::getDayCycleName() const +{ + return mUserPrefs.getDayCycleName(); +} + +void LLEnvManagerNew::setUseRegionSettings(bool val) +{ + mUserPrefs.setUseDefaults(val); + saveUserPrefs(); + updateManagersFromPrefs(); +} + +void LLEnvManagerNew::setUseWaterPreset(const std::string& name) +{ + if (name.empty()) + { + llwarns << "Empty water preset name passed" << llendl; + return; + } + + mUserPrefs.setUseWaterPreset(name); + saveUserPrefs(); + updateManagersFromPrefs(); +} + +void LLEnvManagerNew::setUseSkyPreset(const std::string& name) +{ + if (name.empty()) + { + llwarns << "Empty sky preset name passed" << llendl; + return; + } + + mUserPrefs.setUseSkyPreset(name); + saveUserPrefs(); + updateManagersFromPrefs(); +} + +void LLEnvManagerNew::setUseDayCycle(const std::string& name) +{ + if (name.empty()) + { + llwarns << "Empty day cycle name passed" << llendl; + return; + } + + mUserPrefs.setUseDayCycle(name); + saveUserPrefs(); + updateManagersFromPrefs(); +} + +void LLEnvManagerNew::loadUserPrefs() +{ + // operate on members directly to avoid side effects + mUserPrefs.mWaterPresetName = gSavedSettings.getString("WaterPresetName"); + mUserPrefs.mSkyPresetName = gSavedSettings.getString("SkyPresetName"); + mUserPrefs.mDayCycleName = gSavedSettings.getString("DayCycleName"); + + mUserPrefs.mUseDefaults = gSavedSettings.getBOOL("UseEnvironmentFromRegion"); + mUserPrefs.mUseDayCycle = gSavedSettings.getBOOL("UseDayCycle"); +} + +void LLEnvManagerNew::saveUserPrefs() +{ + gSavedSettings.setString("WaterPresetName", getWaterPresetName()); + gSavedSettings.setString("SkyPresetName", getSkyPresetName()); + gSavedSettings.setString("DayCycleName", getDayCycleName()); + + gSavedSettings.setBOOL("UseEnvironmentFromRegion", getUseRegionSettings()); + gSavedSettings.setBOOL("UseDayCycle", getUseDayCycle()); +} + +void LLEnvManagerNew::onRegionCrossing() +{ + LL_DEBUGS("Windlight") << "Crossed region" << LL_ENDL; + onRegionChange(true); +} + +void LLEnvManagerNew::onLogin() +{ + LL_DEBUGS("Windlight") << "Logged in" << LL_ENDL; + onRegionChange(false); +} + +void LLEnvManagerNew::onTeleport() +{ + LL_DEBUGS("Windlight") << "Teleported" << LL_ENDL; + onRegionChange(false); +} + +//-- private methods ---------------------------------------------------------- + +// virtual +void LLEnvManagerNew::initSingleton() +{ + LL_DEBUGS("Windlight") << "Initializing LLEnvManagerNew" << LL_ENDL; + + loadUserPrefs(); +} + +void LLEnvManagerNew::updateManagersFromPrefs() +{ + // *TODO: apply region settings if user preferences say to do so. + + // Apply water settings. + LLWaterParamManager::instance().applyUserPrefs(); + + // Apply sky settings. + LLWLParamManager::instance().applyUserPrefs(); +} + +void LLEnvManagerNew::sendRegionSettingsRequest() +{ +} + +void LLEnvManagerNew::onRegionChange(bool interpolate) +{ + mInterpNextChangeMessage = interpolate; + sendRegionSettingsRequest(); +} + +void LLEnvManagerNew::onRegionSettingsResponse() +{ + // 1. Refresh cached region settings. + // ... + + // 2. If using server settings, update managers. + if (mUserPrefs.getUseDefaults()) + { + updateManagersFromPrefs(); + } +} -- cgit v1.2.3 From 912f021bb11ef48f352ea85cca27c2bca6ca06b1 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Mon, 16 May 2011 17:17:22 +0300 Subject: STORM-1245 WIP Implement loading and applying region environment settings. --- indra/newview/llenvmanager.cpp | 26 +++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 49bbf1a77c..338a1e5f0a 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -661,6 +661,11 @@ std::string LLEnvManagerNew::getDayCycleName() const return mUserPrefs.getDayCycleName(); } +const LLEnvironmentSettings& LLEnvManagerNew::getRegionSettings() const +{ + return mCachedRegionPrefs; +} + void LLEnvManagerNew::setUseRegionSettings(bool val) { mUserPrefs.setUseDefaults(val); @@ -728,6 +733,16 @@ void LLEnvManagerNew::saveUserPrefs() gSavedSettings.setBOOL("UseDayCycle", getUseDayCycle()); } +void LLEnvManagerNew::dumpUserPrefs() +{ + LL_DEBUGS("Windlight") << "WaterPresetName: " << gSavedSettings.getString("WaterPresetName") << LL_ENDL; + LL_DEBUGS("Windlight") << "SkyPresetName: " << gSavedSettings.getString("SkyPresetName") << LL_ENDL; + LL_DEBUGS("Windlight") << "DayCycleName: " << gSavedSettings.getString("DayCycleName") << LL_ENDL; + + LL_DEBUGS("Windlight") << "UseEnvironmentFromRegion: " << gSavedSettings.getBOOL("UseEnvironmentFromRegion") << LL_ENDL; + LL_DEBUGS("Windlight") << "UseDayCycle: " << gSavedSettings.getBOOL("UseDayCycle") << LL_ENDL; +} + void LLEnvManagerNew::onRegionCrossing() { LL_DEBUGS("Windlight") << "Crossed region" << LL_ENDL; @@ -769,6 +784,8 @@ void LLEnvManagerNew::updateManagersFromPrefs() void LLEnvManagerNew::sendRegionSettingsRequest() { + LLEnvironmentRequest::initiate(); + // *TODO: Indicate that current cached region settings have been invalidated? } void LLEnvManagerNew::onRegionChange(bool interpolate) @@ -777,13 +794,16 @@ void LLEnvManagerNew::onRegionChange(bool interpolate) sendRegionSettingsRequest(); } -void LLEnvManagerNew::onRegionSettingsResponse() +void LLEnvManagerNew::onRegionSettingsResponse(const LLSD& content) { // 1. Refresh cached region settings. - // ... + LL_DEBUGS("Windlight") << "Caching region environment settings" << LL_ENDL; + F32 sun_hour = 0; // *TODO + LLEnvironmentSettings new_settings(content[1], content[2], content[3], sun_hour); + mCachedRegionPrefs = new_settings; // 2. If using server settings, update managers. - if (mUserPrefs.getUseDefaults()) + if (getUseRegionSettings()) { updateManagersFromPrefs(); } -- cgit v1.2.3 From 348218e40f362d386a0175d4b010b639282764b2 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Tue, 17 May 2011 16:26:55 +0300 Subject: STORM-1245 WIP Restored environment settings interpolation on region crossing. Also got rid of duplicated region environment settings requests. --- indra/newview/llenvmanager.cpp | 38 ++++++++++++++++++++++---------------- 1 file changed, 22 insertions(+), 16 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 338a1e5f0a..5a04578e26 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -670,7 +670,7 @@ void LLEnvManagerNew::setUseRegionSettings(bool val) { mUserPrefs.setUseDefaults(val); saveUserPrefs(); - updateManagersFromPrefs(); + updateManagersFromPrefs(false); } void LLEnvManagerNew::setUseWaterPreset(const std::string& name) @@ -683,7 +683,7 @@ void LLEnvManagerNew::setUseWaterPreset(const std::string& name) mUserPrefs.setUseWaterPreset(name); saveUserPrefs(); - updateManagersFromPrefs(); + updateManagersFromPrefs(false); } void LLEnvManagerNew::setUseSkyPreset(const std::string& name) @@ -696,7 +696,7 @@ void LLEnvManagerNew::setUseSkyPreset(const std::string& name) mUserPrefs.setUseSkyPreset(name); saveUserPrefs(); - updateManagersFromPrefs(); + updateManagersFromPrefs(false); } void LLEnvManagerNew::setUseDayCycle(const std::string& name) @@ -709,7 +709,7 @@ void LLEnvManagerNew::setUseDayCycle(const std::string& name) mUserPrefs.setUseDayCycle(name); saveUserPrefs(); - updateManagersFromPrefs(); + updateManagersFromPrefs(true); } void LLEnvManagerNew::loadUserPrefs() @@ -749,12 +749,6 @@ void LLEnvManagerNew::onRegionCrossing() onRegionChange(true); } -void LLEnvManagerNew::onLogin() -{ - LL_DEBUGS("Windlight") << "Logged in" << LL_ENDL; - onRegionChange(false); -} - void LLEnvManagerNew::onTeleport() { LL_DEBUGS("Windlight") << "Teleported" << LL_ENDL; @@ -771,15 +765,13 @@ void LLEnvManagerNew::initSingleton() loadUserPrefs(); } -void LLEnvManagerNew::updateManagersFromPrefs() +void LLEnvManagerNew::updateManagersFromPrefs(bool interpolate) { - // *TODO: apply region settings if user preferences say to do so. - // Apply water settings. - LLWaterParamManager::instance().applyUserPrefs(); + LLWaterParamManager::instance().applyUserPrefs(interpolate); // Apply sky settings. - LLWLParamManager::instance().applyUserPrefs(); + LLWLParamManager::instance().applyUserPrefs(interpolate); } void LLEnvManagerNew::sendRegionSettingsRequest() @@ -790,6 +782,18 @@ void LLEnvManagerNew::sendRegionSettingsRequest() void LLEnvManagerNew::onRegionChange(bool interpolate) { + // Avoid duplicating region setting requests + // by checking whether the region is actually changing. + LLViewerRegion* regionp = gAgent.getRegion(); + LLUUID region_uuid = regionp ? regionp->getRegionID() : LLUUID::null; + if (region_uuid == mCurRegionUUID) + { + return; + } + + // Request environment settings of the new region. + LL_DEBUGS("Windlight") << "New viewer region: " << region_uuid << LL_ENDL; + mCurRegionUUID = region_uuid; mInterpNextChangeMessage = interpolate; sendRegionSettingsRequest(); } @@ -805,6 +809,8 @@ void LLEnvManagerNew::onRegionSettingsResponse(const LLSD& content) // 2. If using server settings, update managers. if (getUseRegionSettings()) { - updateManagersFromPrefs(); + updateManagersFromPrefs(mInterpNextChangeMessage); } + + mInterpNextChangeMessage = false; } -- cgit v1.2.3 From 53d09e7451b89a1c050f3237e6eb5c5ef3b116fc Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Tue, 17 May 2011 16:40:44 +0300 Subject: STORM-1245 WIP Disabled interpolation for switching to using a day cycle. --- indra/newview/llenvmanager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 5a04578e26..dfec6c4b9d 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -709,7 +709,7 @@ void LLEnvManagerNew::setUseDayCycle(const std::string& name) mUserPrefs.setUseDayCycle(name); saveUserPrefs(); - updateManagersFromPrefs(true); + updateManagersFromPrefs(false); } void LLEnvManagerNew::loadUserPrefs() -- cgit v1.2.3 From ec749bb1c1fa143c6019791d6713d85f05510e53 Mon Sep 17 00:00:00 2001 From: Seth ProductEngine Date: Tue, 17 May 2011 17:09:15 +0300 Subject: STORM-1244 FIXED Environment Settings floater implementation. --- indra/newview/llenvmanager.cpp | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index dfec6c4b9d..bc1e0f8b14 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -82,6 +82,7 @@ void LLEnvManager::changedRegion(bool interp) mInterpNextChangeMessage = interp; mPendingOutgoingMessage = false; + LLFloaterReg::hideInstance("old_env_settings"); LLFloaterReg::hideInstance("env_settings"); resetInternalsToDefault(LLEnvKey::SCOPE_REGION); @@ -733,6 +734,25 @@ void LLEnvManagerNew::saveUserPrefs() gSavedSettings.setBOOL("UseDayCycle", getUseDayCycle()); } +void LLEnvManagerNew::setUserPrefs( + const std::string& water_preset, + const std::string& sky_preset, + const std::string& day_cycle_preset, + bool use_fixed_sky, + bool use_region_settings) +{ + // operate on members directly to avoid side effects + mUserPrefs.mWaterPresetName = water_preset; + mUserPrefs.mSkyPresetName = sky_preset; + mUserPrefs.mDayCycleName = day_cycle_preset; + + mUserPrefs.mUseDefaults = use_region_settings; + mUserPrefs.mUseDayCycle = !use_fixed_sky; + + saveUserPrefs(); + updateManagersFromPrefs(false); +} + void LLEnvManagerNew::dumpUserPrefs() { LL_DEBUGS("Windlight") << "WaterPresetName: " << gSavedSettings.getString("WaterPresetName") << LL_ENDL; -- cgit v1.2.3 From 0c358f78ab618de8727892a50cd3a3055dbdf956 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Thu, 19 May 2011 21:10:34 +0300 Subject: STORM-1269 FIXED Teleport to a region that has no env. settings now resets environment to defaults. --- indra/newview/llenvmanager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index bc1e0f8b14..b670c730a7 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -821,7 +821,7 @@ void LLEnvManagerNew::onRegionChange(bool interpolate) void LLEnvManagerNew::onRegionSettingsResponse(const LLSD& content) { // 1. Refresh cached region settings. - LL_DEBUGS("Windlight") << "Caching region environment settings" << LL_ENDL; + LL_DEBUGS("Windlight") << "Caching region environment settings: " << content << LL_ENDL; F32 sun_hour = 0; // *TODO LLEnvironmentSettings new_settings(content[1], content[2], content[3], sun_hour); mCachedRegionPrefs = new_settings; -- cgit v1.2.3 From 60f54abb33a8a0f4f3bd0fa23aee84d695486f92 Mon Sep 17 00:00:00 2001 From: Oz Linden Date: Fri, 20 May 2011 09:48:19 -0400 Subject: STORM-1265: partial fix for region updates; further integration with new dialogs needed. --- indra/newview/llenvmanager.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index b670c730a7..633b9c7c52 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -127,7 +127,7 @@ void LLEnvManager::startEditingScope(LLEnvKey::EScope scope) // not implemented here (yet) return; case LLEnvKey::SCOPE_REGION: - LLPanelRegionTerrainInfo::instance()->setCommitControls(true); + /* LLPanelRegionTerrainInfo::instance()->setCommitControls(true); the windlight settings are no longer on the region terrain panel */ break; default: return; @@ -182,7 +182,7 @@ void LLEnvManager::clearEditingScope(const LLSD& notification, const LLSD& respo mIsEditing = false; updateUIFromEditability(); - LLPanelRegionTerrainInfo::instance()->cancelChanges(); + /* LLPanelRegionTerrainInfo::instance()->cancelChanges(); the terrain panel no longer has windlight data - if this is needed, it should move. */ loadSettingsIntoManagers(mCurNormalScope, true); } @@ -305,6 +305,7 @@ bool LLEnvManager::processIncomingMessage(const LLSD& unvalidated_content, const if (valid) { + // TODO - the sun controls are moving; this should be updated F32 sun_hour = 0; LLPanelRegionTerrainInfo* terrain_panel = LLPanelRegionTerrainInfo::instance(); -- cgit v1.2.3 From b60c63bf075a92084ba94459a840decba846a916 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Mon, 23 May 2011 19:26:17 +0300 Subject: STORM-1256 WIP Implemented editing region environment settings via the Region/Estate floater. --- indra/newview/llenvmanager.cpp | 28 ++++++++++++++++++++++++---- 1 file changed, 24 insertions(+), 4 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 633b9c7c52..0391a5adb2 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -367,7 +367,7 @@ void LLEnvManager::commitSettings(LLEnvKey::EScope scope) metadata["messageID"] = mLastReceivedID; // add last received update ID to outbound message so simulator can handle concurrent updates saveSettingsFromManagers(scope); // save current settings into settings store before grabbing from settings store and sending - success = LLEnvironmentApplyResponder::initiateRequest(makePacket(LLEnvKey::SCOPE_REGION, metadata)); + success = LLEnvironmentApply::initiateRequest(makePacket(LLEnvKey::SCOPE_REGION, metadata)); if(success) { // while waiting for the return message, render old settings @@ -484,7 +484,7 @@ void LLEnvManager::saveSettingsFromManagers(LLEnvKey::EScope scope) { // ensure only referenced region-scope skies are saved, resolve naming collisions, etc. std::map final_references = LLWLParamManager::getInstance()->finalizeFromDayCycle(scope); - LLSD referenced_skies = LLWLParamManager::getInstance()->createSkyMap(final_references); + LLSD referenced_skies = LLWLParamManager::createSkyMap(final_references); LL_DEBUGS("Windlight Sync") << "Dumping referenced skies (" << final_references.size() << ") to LLSD: " << referenced_skies << LL_ENDL; @@ -764,6 +764,23 @@ void LLEnvManagerNew::dumpUserPrefs() LL_DEBUGS("Windlight") << "UseDayCycle: " << gSavedSettings.getBOOL("UseDayCycle") << LL_ENDL; } +// static +LLSD LLEnvManagerNew::getDayCycleByName(const std::string name) +{ + return LLWLDayCycle::loadCycleDataFromFile(name + ".xml"); +} + +bool LLEnvManagerNew::sendRegionSettings(const LLEnvironmentSettings& new_settings) +{ + LLSD metadata; + + metadata["regionID"] = gAgent.getRegion()->getRegionID(); + // add last received update ID to outbound message so simulator can handle concurrent updates + metadata["messageID"] = mLastReceivedID; + + return LLEnvironmentApply::initiateRequest(new_settings.makePacket(metadata)); +} + void LLEnvManagerNew::onRegionCrossing() { LL_DEBUGS("Windlight") << "Crossed region" << LL_ENDL; @@ -795,7 +812,7 @@ void LLEnvManagerNew::updateManagersFromPrefs(bool interpolate) LLWLParamManager::instance().applyUserPrefs(interpolate); } -void LLEnvManagerNew::sendRegionSettingsRequest() +void LLEnvManagerNew::requestRegionSettings() { LLEnvironmentRequest::initiate(); // *TODO: Indicate that current cached region settings have been invalidated? @@ -816,11 +833,14 @@ void LLEnvManagerNew::onRegionChange(bool interpolate) LL_DEBUGS("Windlight") << "New viewer region: " << region_uuid << LL_ENDL; mCurRegionUUID = region_uuid; mInterpNextChangeMessage = interpolate; - sendRegionSettingsRequest(); + requestRegionSettings(); } void LLEnvManagerNew::onRegionSettingsResponse(const LLSD& content) { + // If the message was valid, grab the UUID from it and save it for next outbound update message. + mLastReceivedID = content[0]["messageID"].asUUID(); + // 1. Refresh cached region settings. LL_DEBUGS("Windlight") << "Caching region environment settings: " << content << LL_ENDL; F32 sun_hour = 0; // *TODO -- cgit v1.2.3 From 3befc1b988c0eae0d344b31a361166c734c91a3d Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Mon, 23 May 2011 19:30:05 +0300 Subject: STORM-1256 WIP Moved a public method to the appropriate place. --- indra/newview/llenvmanager.cpp | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 0391a5adb2..9f15f9adfc 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -793,6 +793,26 @@ void LLEnvManagerNew::onTeleport() onRegionChange(false); } +void LLEnvManagerNew::onRegionSettingsResponse(const LLSD& content) +{ + // If the message was valid, grab the UUID from it and save it for next outbound update message. + mLastReceivedID = content[0]["messageID"].asUUID(); + + // 1. Refresh cached region settings. + LL_DEBUGS("Windlight") << "Caching region environment settings: " << content << LL_ENDL; + F32 sun_hour = 0; // *TODO + LLEnvironmentSettings new_settings(content[1], content[2], content[3], sun_hour); + mCachedRegionPrefs = new_settings; + + // 2. If using server settings, update managers. + if (getUseRegionSettings()) + { + updateManagersFromPrefs(mInterpNextChangeMessage); + } + + mInterpNextChangeMessage = false; +} + //-- private methods ---------------------------------------------------------- // virtual @@ -835,23 +855,3 @@ void LLEnvManagerNew::onRegionChange(bool interpolate) mInterpNextChangeMessage = interpolate; requestRegionSettings(); } - -void LLEnvManagerNew::onRegionSettingsResponse(const LLSD& content) -{ - // If the message was valid, grab the UUID from it and save it for next outbound update message. - mLastReceivedID = content[0]["messageID"].asUUID(); - - // 1. Refresh cached region settings. - LL_DEBUGS("Windlight") << "Caching region environment settings: " << content << LL_ENDL; - F32 sun_hour = 0; // *TODO - LLEnvironmentSettings new_settings(content[1], content[2], content[3], sun_hour); - mCachedRegionPrefs = new_settings; - - // 2. If using server settings, update managers. - if (getUseRegionSettings()) - { - updateManagersFromPrefs(mInterpNextChangeMessage); - } - - mInterpNextChangeMessage = false; -} -- cgit v1.2.3 From 9c2c6c7a6c48753e722748a7ae5cd4e2174f5630 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Tue, 24 May 2011 15:28:20 +0300 Subject: STORM-1256 WIP Improvements to region enviroment settings editing. * Enable/disable controls according to the region permissions. * Update controls when region settings update comes. --- indra/newview/llenvmanager.cpp | 32 ++++++++++++++++++++++++-------- 1 file changed, 24 insertions(+), 8 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 9f15f9adfc..688e2ea9bf 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -770,6 +770,11 @@ LLSD LLEnvManagerNew::getDayCycleByName(const std::string name) return LLWLDayCycle::loadCycleDataFromFile(name + ".xml"); } +void LLEnvManagerNew::requestRegionSettings() +{ + LLEnvironmentRequest::initiate(); +} + bool LLEnvManagerNew::sendRegionSettings(const LLEnvironmentSettings& new_settings) { LLSD metadata; @@ -781,6 +786,16 @@ bool LLEnvManagerNew::sendRegionSettings(const LLEnvironmentSettings& new_settin return LLEnvironmentApply::initiateRequest(new_settings.makePacket(metadata)); } +boost::signals2::connection LLEnvManagerNew::setRegionSettingsChangeCallback(const region_settings_change_signal_t::slot_type& cb) +{ + return mRegionSettingsChangeSignal.connect(cb); +} + +boost::signals2::connection LLEnvManagerNew::setRegionChangeCallback(const region_change_signal_t::slot_type& cb) +{ + return mRegionChangeSignal.connect(cb); +} + void LLEnvManagerNew::onRegionCrossing() { LL_DEBUGS("Windlight") << "Crossed region" << LL_ENDL; @@ -798,18 +813,22 @@ void LLEnvManagerNew::onRegionSettingsResponse(const LLSD& content) // If the message was valid, grab the UUID from it and save it for next outbound update message. mLastReceivedID = content[0]["messageID"].asUUID(); - // 1. Refresh cached region settings. + // Refresh cached region settings. LL_DEBUGS("Windlight") << "Caching region environment settings: " << content << LL_ENDL; F32 sun_hour = 0; // *TODO LLEnvironmentSettings new_settings(content[1], content[2], content[3], sun_hour); mCachedRegionPrefs = new_settings; - // 2. If using server settings, update managers. + // If using server settings, update managers. if (getUseRegionSettings()) { updateManagersFromPrefs(mInterpNextChangeMessage); } + // Let interested parties know about the region settings update. + mRegionSettingsChangeSignal(); + + // reset mInterpNextChangeMessage = false; } @@ -832,12 +851,6 @@ void LLEnvManagerNew::updateManagersFromPrefs(bool interpolate) LLWLParamManager::instance().applyUserPrefs(interpolate); } -void LLEnvManagerNew::requestRegionSettings() -{ - LLEnvironmentRequest::initiate(); - // *TODO: Indicate that current cached region settings have been invalidated? -} - void LLEnvManagerNew::onRegionChange(bool interpolate) { // Avoid duplicating region setting requests @@ -854,4 +867,7 @@ void LLEnvManagerNew::onRegionChange(bool interpolate) mCurRegionUUID = region_uuid; mInterpNextChangeMessage = interpolate; requestRegionSettings(); + + // Let interested parties know agent region has been changed. + mRegionChangeSignal(); } -- cgit v1.2.3 From 047f69bf618fa525410dc512977e384cbbdb4d11 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Tue, 24 May 2011 19:05:41 +0300 Subject: STORM-1256 WIP Fixed resetting the Environment tab if a server env. update comes while your preference is using personal env. settings. The fix is to re-add server skies to our WL param mgr regardless of user preferences. --- indra/newview/llenvmanager.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 688e2ea9bf..85a7c4d069 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -820,10 +820,8 @@ void LLEnvManagerNew::onRegionSettingsResponse(const LLSD& content) mCachedRegionPrefs = new_settings; // If using server settings, update managers. - if (getUseRegionSettings()) - { - updateManagersFromPrefs(mInterpNextChangeMessage); - } + // This also adds server skies to the WL param mgr. + updateManagersFromPrefs(mInterpNextChangeMessage); // Let interested parties know about the region settings update. mRegionSettingsChangeSignal(); -- cgit v1.2.3 From d755605f8dc5bba0abdb87f075db2b6a5ed4ecad Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Tue, 24 May 2011 20:21:23 +0300 Subject: STORM-1256 WIP Added perpetual indicator for progress of applying changes. --- indra/newview/llenvmanager.cpp | 11 +++++++++++ 1 file changed, 11 insertions(+) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 85a7c4d069..a08ca88459 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -796,6 +796,11 @@ boost::signals2::connection LLEnvManagerNew::setRegionChangeCallback(const regio return mRegionChangeSignal.connect(cb); } +boost::signals2::connection LLEnvManagerNew::setRegionSettingsAppliedCallback(const region_settings_applied_signal_t::slot_type& cb) +{ + return mRegionSettingsAppliedSignal.connect(cb); +} + void LLEnvManagerNew::onRegionCrossing() { LL_DEBUGS("Windlight") << "Crossed region" << LL_ENDL; @@ -830,6 +835,12 @@ void LLEnvManagerNew::onRegionSettingsResponse(const LLSD& content) mInterpNextChangeMessage = false; } +void LLEnvManagerNew::onRegionSettingsApplyResponse(bool ok) +{ + LL_DEBUGS("Windlight") << "Applying region settings " << (ok ? "succeeded" : "failed") << LL_ENDL; + mRegionSettingsAppliedSignal(ok); +} + //-- private methods ---------------------------------------------------------- // virtual -- cgit v1.2.3 From c32b19f31d4d5d0b32fcf64cce1cebd7d79b9b05 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Thu, 26 May 2011 15:11:01 +0300 Subject: STORM-1253 WIP Implemented switching between multiple day cycles (locally and region-wide). --- indra/newview/llenvmanager.cpp | 6 ------ 1 file changed, 6 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index a08ca88459..f12c3e54ff 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -764,12 +764,6 @@ void LLEnvManagerNew::dumpUserPrefs() LL_DEBUGS("Windlight") << "UseDayCycle: " << gSavedSettings.getBOOL("UseDayCycle") << LL_ENDL; } -// static -LLSD LLEnvManagerNew::getDayCycleByName(const std::string name) -{ - return LLWLDayCycle::loadCycleDataFromFile(name + ".xml"); -} - void LLEnvManagerNew::requestRegionSettings() { LLEnvironmentRequest::initiate(); -- cgit v1.2.3 From c0037909d576fc4922b92dfcc83d865d61ac43cb Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Thu, 26 May 2011 19:32:20 +0300 Subject: STORM-1284 FIXED Changes to region environment are now visible immediately. Pressing "Apply" sends the settings update to server. Pressing "Cancel" reverts to current region settings. --- indra/newview/llenvmanager.cpp | 78 ++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 76 insertions(+), 2 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index f12c3e54ff..d5d03ff1e5 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -37,6 +37,7 @@ #include "llagent.h" #include "llviewerregion.h" +#include "lldaycyclemanager.h" #include "llfloaterreg.h" #include "llfloaterwindlight.h" #include "llfloaterwater.h" @@ -668,6 +669,74 @@ const LLEnvironmentSettings& LLEnvManagerNew::getRegionSettings() const return mCachedRegionPrefs; } +bool LLEnvManagerNew::usePrefs() +{ + LL_DEBUGS("Windlight") << "Displaying preferred environment" << LL_ENDL; + updateManagersFromPrefs(false); + return true; +} + +bool LLEnvManagerNew::useDefaults() +{ + bool rslt = useWaterPreset("Default") && useDayCycle("Default", LLEnvKey::SCOPE_LOCAL); + return rslt; +} + +bool LLEnvManagerNew::useWaterPreset(const std::string& name) +{ + LL_DEBUGS("Windlight") << "Displaying water preset " << name << LL_ENDL; + LLWaterParamManager& water_mgr = LLWaterParamManager::instance(); + bool rslt = water_mgr.getParamSet(name, water_mgr.mCurParams); + llassert(rslt == true); + return rslt; +} + +bool LLEnvManagerNew::useWaterParams(const LLSD& params) +{ + LL_DEBUGS("Windlight") << "Displaying water params" << LL_ENDL; + LLWaterParamManager::instance().mCurParams.setAll(params); + return true; +} + +bool LLEnvManagerNew::useSkyParams(const LLSD& params) +{ + LL_DEBUGS("Windlight") << "Displaying sky params" << LL_ENDL; + LLWLParamManager::instance().applySkyParams(params); + return true; +} + +bool LLEnvManagerNew::useDayCycle(const std::string& name, LLEnvKey::EScope scope) +{ + LLSD params; + + if (scope == LLEnvKey::SCOPE_REGION) + { + LL_DEBUGS("Windlight") << "Displaying region day cycle " << name << LL_ENDL; + params = getRegionSettings().getWLDayCycle(); + } + else + { + LL_DEBUGS("Windlight") << "Displaying local day cycle " << name << LL_ENDL; + + if (!LLDayCycleManager::instance().getPreset(name, params)) + { + llwarns << "No day cycle named " << name << llendl; + return false; + } + } + + bool rslt = LLWLParamManager::instance().applyDayCycleParams(params, scope); + llassert(rslt == true); + return rslt; +} + +bool LLEnvManagerNew::useDayCycleParams(const LLSD& params, LLEnvKey::EScope scope) +{ + LL_DEBUGS("Windlight") << "Displaying day cycle params" << LL_ENDL; + LLWLParamManager::instance().applyDayCycleParams(params, scope); + return true; +} + void LLEnvManagerNew::setUseRegionSettings(bool val) { mUserPrefs.setUseDefaults(val); @@ -818,9 +887,14 @@ void LLEnvManagerNew::onRegionSettingsResponse(const LLSD& content) LLEnvironmentSettings new_settings(content[1], content[2], content[3], sun_hour); mCachedRegionPrefs = new_settings; + // Load region sky presets. + LLWLParamManager::instance().refreshRegionPresets(); + // If using server settings, update managers. - // This also adds server skies to the WL param mgr. - updateManagersFromPrefs(mInterpNextChangeMessage); + if (getUseRegionSettings()) + { + updateManagersFromPrefs(mInterpNextChangeMessage); + } // Let interested parties know about the region settings update. mRegionSettingsChangeSignal(); -- cgit v1.2.3 From 657e434fd59139436e8b97e5ecd01ca686e82269 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Mon, 30 May 2011 22:34:56 +0300 Subject: STORM-1253 WIP New day cycle editor. Done: * Creating new local day cycles. * Editing existing local day cycles. * Deleting day cycles. To do: * Editing region day cycle, dealing with skies in region scope. * Handle teleport while editing a day cycle. * Update UI when a day cycle or sky preset gets deleted. * Make the time ctrl increase/decrease consistently. --- indra/newview/llenvmanager.cpp | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index d5d03ff1e5..48d84fcffc 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -746,6 +746,7 @@ void LLEnvManagerNew::setUseRegionSettings(bool val) void LLEnvManagerNew::setUseWaterPreset(const std::string& name) { + // *TODO: make sure the preset exists. if (name.empty()) { llwarns << "Empty water preset name passed" << llendl; @@ -759,6 +760,7 @@ void LLEnvManagerNew::setUseWaterPreset(const std::string& name) void LLEnvManagerNew::setUseSkyPreset(const std::string& name) { + // *TODO: make sure the preset exists. if (name.empty()) { llwarns << "Empty sky preset name passed" << llendl; @@ -772,9 +774,9 @@ void LLEnvManagerNew::setUseSkyPreset(const std::string& name) void LLEnvManagerNew::setUseDayCycle(const std::string& name) { - if (name.empty()) + if (!LLDayCycleManager::instance().presetExists(name)) { - llwarns << "Empty day cycle name passed" << llendl; + llwarns << "Invalid day cycle name passed" << llendl; return; } @@ -939,6 +941,8 @@ void LLEnvManagerNew::onRegionChange(bool interpolate) return; } + // *TODO: clear environment settings of the previous region? + // Request environment settings of the new region. LL_DEBUGS("Windlight") << "New viewer region: " << region_uuid << LL_ENDL; mCurRegionUUID = region_uuid; -- cgit v1.2.3 From dda7df4ac94d1e269aa0ce9eff6c6078f756cbd9 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Thu, 2 Jun 2011 18:35:23 +0300 Subject: STORM-1253 WIP Debugging stuff. --- indra/newview/llenvmanager.cpp | 50 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 48d84fcffc..dd8db7b785 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -835,6 +835,56 @@ void LLEnvManagerNew::dumpUserPrefs() LL_DEBUGS("Windlight") << "UseDayCycle: " << gSavedSettings.getBOOL("UseDayCycle") << LL_ENDL; } +void LLEnvManagerNew::dumpPresets() +{ + const LLEnvironmentSettings& region_settings = getRegionSettings(); + std::string region_name = gAgent.getRegion() ? gAgent.getRegion()->getName() : "Unknown region"; + + // Dump water presets. + LL_DEBUGS("Windlight") << "Waters:" << LL_ENDL; + if (region_settings.getWaterParams().size() != 0) + { + LL_DEBUGS("Windlight") << " - " << region_name << LL_ENDL; + } + const std::map &water_params_map = LLWaterParamManager::instance().mParamList; + for (std::map::const_iterator it = water_params_map.begin(); it != water_params_map.end(); it++) + { + LL_DEBUGS("Windlight") << " - " << it->first << LL_ENDL; + } + + // Dump sky presets. + LL_DEBUGS("Windlight") << "Skies:" << LL_ENDL; + const std::map &sky_params_map = LLWLParamManager::getInstance()->mParamList; + for (std::map::const_iterator it = sky_params_map.begin(); it != sky_params_map.end(); it++) + { + std::string preset_name = it->first.name; + std::string item_title; + + if (it->first.scope == LLEnvKey::SCOPE_LOCAL) // local preset + { + item_title = preset_name; + } + else // region preset + { + item_title = preset_name + " (" + region_name + ")"; + } + LL_DEBUGS("Windlight") << " - " << item_title << LL_ENDL; + } + + // Dump day cycles. + LL_DEBUGS("Windlight") << "Days:" << LL_ENDL; + const LLSD& cur_region_dc = region_settings.getWLDayCycle(); + if (cur_region_dc.size() != 0) + { + LL_DEBUGS("Windlight") << " - " << region_name << LL_ENDL; + } + const LLDayCycleManager::dc_map_t& map = LLDayCycleManager::instance().getPresets(); + for (LLDayCycleManager::dc_map_t::const_iterator it = map.begin(); it != map.end(); ++it) + { + LL_DEBUGS("Windlight") << " - " << it->first << LL_ENDL; + } +} + void LLEnvManagerNew::requestRegionSettings() { LLEnvironmentRequest::initiate(); -- cgit v1.2.3 From e184c7598680f2069e2bcf5caa3c86967d7ab0a1 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Thu, 2 Jun 2011 18:56:49 +0300 Subject: STORM-1253 WIP Changed the workflow to modify region day cycle. Was: Press "Save" after editing the region day cycle in the Day Cycle Editor. Now: - Press "Save" in the Day Cycle Editor. - Open Region / Estate -> Environment tab. - Select the region day cycle. - Press "Apply". --- indra/newview/llenvmanager.cpp | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index dd8db7b785..8e4b7197d6 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -666,7 +666,14 @@ std::string LLEnvManagerNew::getDayCycleName() const const LLEnvironmentSettings& LLEnvManagerNew::getRegionSettings() const { - return mCachedRegionPrefs; + return !mNewRegionPrefs.isEmpty() ? mNewRegionPrefs : mCachedRegionPrefs; +} + +void LLEnvManagerNew::setRegionSettings(const LLEnvironmentSettings& new_settings) +{ + // Set region settings override that will be used locally + // until user either uploads the changes or goes to another region. + mNewRegionPrefs = new_settings; } bool LLEnvManagerNew::usePrefs() @@ -958,6 +965,10 @@ void LLEnvManagerNew::onRegionSettingsResponse(const LLSD& content) void LLEnvManagerNew::onRegionSettingsApplyResponse(bool ok) { LL_DEBUGS("Windlight") << "Applying region settings " << (ok ? "succeeded" : "failed") << LL_ENDL; + + // Clear locally modified region settings because they have just been uploaded. + mNewRegionPrefs.clear(); + mRegionSettingsAppliedSignal(ok); } @@ -991,6 +1002,9 @@ void LLEnvManagerNew::onRegionChange(bool interpolate) return; } + // Clear locally modified region settings. + mNewRegionPrefs.clear(); + // *TODO: clear environment settings of the previous region? // Request environment settings of the new region. -- cgit v1.2.3 From 9f4779e09997e70246c3c0c5f831bf55d4ed6a4f Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Mon, 6 Jun 2011 23:46:35 +0300 Subject: STORM-1255 WIP Made the check for region permissions reusable. --- indra/newview/llenvmanager.cpp | 11 +++++++++++ 1 file changed, 11 insertions(+) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 8e4b7197d6..58d1349a63 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -923,6 +923,17 @@ boost::signals2::connection LLEnvManagerNew::setRegionSettingsAppliedCallback(co return mRegionSettingsAppliedSignal.connect(cb); } +// static +bool LLEnvManagerNew::canEditRegionSettings() +{ + LLViewerRegion* region = gAgent.getRegion(); + BOOL owner_or_god = gAgent.isGodlike() || (region && region->getOwner() == gAgent.getID()); + BOOL owner_or_god_or_manager = owner_or_god || (region && region->isEstateManager()); + + LL_DEBUGS("Windlight") << "Can edit region settings: " << (bool) owner_or_god_or_manager << LL_ENDL; + return owner_or_god_or_manager; +} + void LLEnvManagerNew::onRegionCrossing() { LL_DEBUGS("Windlight") << "Crossed region" << LL_ENDL; -- cgit v1.2.3 From a7603c84879e7a2d0f72d64e5988aae332d463c1 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Thu, 9 Jun 2011 21:56:33 +0300 Subject: STORM-1279 WIP Renamed a method. --- indra/newview/llenvmanager.cpp | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 58d1349a63..03b37ecaed 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -596,27 +596,27 @@ std::string LLEnvPrefs::getDayCycleName() const return mDayCycleName; } -void LLEnvPrefs::setUseDefaults(bool val) +void LLEnvPrefs::setUseRegionSettings(bool val) { - mUseDefaults = val; + mUseRegionSettings = val; } void LLEnvPrefs::setUseWaterPreset(const std::string& name) { - setUseDefaults(false); + mUseRegionSettings = false; mWaterPresetName = name; } void LLEnvPrefs::setUseSkyPreset(const std::string& name) { - setUseDefaults(false); + mUseRegionSettings = false; mUseDayCycle = false; mSkyPresetName = name; } void LLEnvPrefs::setUseDayCycle(const std::string& name) { - setUseDefaults(false); + mUseRegionSettings = false; mUseDayCycle = true; mDayCycleName = name; } @@ -627,7 +627,7 @@ LLEnvManagerNew::LLEnvManagerNew() mInterpNextChangeMessage = true; // Set default environment settings. - mUserPrefs.mUseDefaults = true; + mUserPrefs.mUseRegionSettings = true; mUserPrefs.mUseDayCycle = true; mUserPrefs.mWaterPresetName = "Default"; mUserPrefs.mSkyPresetName = "Default"; @@ -636,7 +636,7 @@ LLEnvManagerNew::LLEnvManagerNew() bool LLEnvManagerNew::getUseRegionSettings() const { - return mUserPrefs.getUseDefaults(); + return mUserPrefs.getUseRegionSettings(); } bool LLEnvManagerNew::getUseDayCycle() const @@ -746,7 +746,7 @@ bool LLEnvManagerNew::useDayCycleParams(const LLSD& params, LLEnvKey::EScope sco void LLEnvManagerNew::setUseRegionSettings(bool val) { - mUserPrefs.setUseDefaults(val); + mUserPrefs.setUseRegionSettings(val); saveUserPrefs(); updateManagersFromPrefs(false); } @@ -799,8 +799,8 @@ void LLEnvManagerNew::loadUserPrefs() mUserPrefs.mSkyPresetName = gSavedSettings.getString("SkyPresetName"); mUserPrefs.mDayCycleName = gSavedSettings.getString("DayCycleName"); - mUserPrefs.mUseDefaults = gSavedSettings.getBOOL("UseEnvironmentFromRegion"); - mUserPrefs.mUseDayCycle = gSavedSettings.getBOOL("UseDayCycle"); + mUserPrefs.mUseRegionSettings = gSavedSettings.getBOOL("UseEnvironmentFromRegion"); + mUserPrefs.mUseDayCycle = gSavedSettings.getBOOL("UseDayCycle"); } void LLEnvManagerNew::saveUserPrefs() @@ -825,8 +825,8 @@ void LLEnvManagerNew::setUserPrefs( mUserPrefs.mSkyPresetName = sky_preset; mUserPrefs.mDayCycleName = day_cycle_preset; - mUserPrefs.mUseDefaults = use_region_settings; - mUserPrefs.mUseDayCycle = !use_fixed_sky; + mUserPrefs.mUseRegionSettings = use_region_settings; + mUserPrefs.mUseDayCycle = !use_fixed_sky; saveUserPrefs(); updateManagersFromPrefs(false); -- cgit v1.2.3 From 0d1cc56eb128755ce9e63d8cdf852b0e3b6f4fb1 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Fri, 10 Jun 2011 18:21:32 +0300 Subject: STORM-1279 FIXED Changing sky preset with a keyboard shortcut now updates the Environment Settings floater. Changes: * Subscribed the floater to the "settings changed" signal of the environment manager. * Rewrote the floater to not modify settings only when the Save button is pressed. * Refactoring to eliminate code duplication. --- indra/newview/llenvmanager.cpp | 174 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 168 insertions(+), 6 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 03b37ecaed..6b506574b6 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -685,7 +685,21 @@ bool LLEnvManagerNew::usePrefs() bool LLEnvManagerNew::useDefaults() { - bool rslt = useWaterPreset("Default") && useDayCycle("Default", LLEnvKey::SCOPE_LOCAL); + bool rslt; + + rslt = useDefaultWater(); + rslt &= useDefaultSky(); + + return rslt; +} + +bool LLEnvManagerNew::useRegionSettings() +{ + bool rslt; + + rslt = useRegionSky(); + rslt &= useRegionWater(); + return rslt; } @@ -705,6 +719,22 @@ bool LLEnvManagerNew::useWaterParams(const LLSD& params) return true; } +bool LLEnvManagerNew::useSkyPreset(const std::string& name) +{ + LLWLParamManager& sky_mgr = LLWLParamManager::instance(); + LLWLParamSet param_set; + + if (!sky_mgr.getParamSet(LLWLParamKey(name, LLEnvKey::SCOPE_LOCAL), param_set)) + { + llwarns << "No sky preset named " << name << llendl; + return false; + } + + LL_DEBUGS("Windlight") << "Displaying sky preset " << name << LL_ENDL; + sky_mgr.applySkyParams(param_set.getAll()); + return true; +} + bool LLEnvManagerNew::useSkyParams(const LLSD& params) { LL_DEBUGS("Windlight") << "Displaying sky params" << LL_ENDL; @@ -737,11 +767,10 @@ bool LLEnvManagerNew::useDayCycle(const std::string& name, LLEnvKey::EScope scop return rslt; } -bool LLEnvManagerNew::useDayCycleParams(const LLSD& params, LLEnvKey::EScope scope) +bool LLEnvManagerNew::useDayCycleParams(const LLSD& params, LLEnvKey::EScope scope, F32 time /* = 0.5*/) { LL_DEBUGS("Windlight") << "Displaying day cycle params" << LL_ENDL; - LLWLParamManager::instance().applyDayCycleParams(params, scope); - return true; + return LLWLParamManager::instance().applyDayCycleParams(params, scope); } void LLEnvManagerNew::setUseRegionSettings(bool val) @@ -811,6 +840,8 @@ void LLEnvManagerNew::saveUserPrefs() gSavedSettings.setBOOL("UseEnvironmentFromRegion", getUseRegionSettings()); gSavedSettings.setBOOL("UseDayCycle", getUseDayCycle()); + + mUsePrefsChangeSignal(); } void LLEnvManagerNew::setUserPrefs( @@ -908,6 +939,11 @@ bool LLEnvManagerNew::sendRegionSettings(const LLEnvironmentSettings& new_settin return LLEnvironmentApply::initiateRequest(new_settings.makePacket(metadata)); } +boost::signals2::connection LLEnvManagerNew::setPreferencesChangeCallback(const prefs_change_signal_t::slot_type& cb) +{ + return mUsePrefsChangeSignal.connect(cb); +} + boost::signals2::connection LLEnvManagerNew::setRegionSettingsChangeCallback(const region_settings_change_signal_t::slot_type& cb) { return mRegionSettingsChangeSignal.connect(cb); @@ -993,15 +1029,141 @@ void LLEnvManagerNew::initSingleton() loadUserPrefs(); } +void LLEnvManagerNew::updateSkyFromPrefs() +{ + bool success = true; + + // Sync sky with user prefs. + if (getUseRegionSettings()) // apply region-wide settings + { + success = useRegionSky(); + } + else // apply user-specified settings + { + if (getUseDayCycle()) + { + success = useDayCycle(getDayCycleName(), LLEnvKey::SCOPE_LOCAL); + } + else + { + success = useSkyPreset(getSkyPresetName()); + } + } + + // If something went wrong, fall back to defaults. + if (!success) + { + // *TODO: fix user prefs + useDefaultSky(); + } +} + +void LLEnvManagerNew::updateWaterFromPrefs(bool interpolate) +{ + LLWaterParamManager& water_mgr = LLWaterParamManager::instance(); + LLSD target_water_params; + + // Determine new water settings based on user prefs. + + { + // Fall back to default water. + LLWaterParamSet default_water; + water_mgr.getParamSet("Default", default_water); + target_water_params = default_water.getAll(); + } + + if (getUseRegionSettings()) + { + // *TODO: make sure whether region settings belong to the current region? + const LLSD& region_water_params = getRegionSettings().getWaterParams(); + if (region_water_params.size() != 0) // region has no water settings + { + LL_DEBUGS("Windlight") << "Applying region water" << LL_ENDL; + target_water_params = region_water_params; + } + else + { + LL_DEBUGS("Windlight") << "Applying default water" << LL_ENDL; + } + } + else + { + std::string water = getWaterPresetName(); + LL_DEBUGS("Windlight") << "Applying water preset [" << water << "]" << LL_ENDL; + LLWaterParamSet params; + if (!water_mgr.getParamSet(water, params)) + { + llwarns << "No water preset named " << water << ", falling back to defaults" << llendl; + water_mgr.getParamSet("Default", params); + + // *TODO: Fix user preferences accordingly. + } + target_water_params = params.getAll(); + } + + // Sync water with user prefs. + water_mgr.applyParams(target_water_params, interpolate); +} + void LLEnvManagerNew::updateManagersFromPrefs(bool interpolate) { // Apply water settings. - LLWaterParamManager::instance().applyUserPrefs(interpolate); + updateWaterFromPrefs(interpolate); // Apply sky settings. - LLWLParamManager::instance().applyUserPrefs(interpolate); + updateSkyFromPrefs(); } +bool LLEnvManagerNew::useRegionSky() +{ + const LLEnvironmentSettings& region_settings = getRegionSettings(); + + // If region is set to defaults, + if (region_settings.getSkyMap().size() == 0) + { + // well... apply the default sky settings. + useDefaultSky(); + return true; + } + + // *TODO: Support fixed sky from region. + + // Otherwise apply region day cycle. + LL_DEBUGS("Windlight") << "Applying region sky" << LL_ENDL; + return useDayCycleParams( + region_settings.getWLDayCycle(), + LLEnvKey::SCOPE_REGION, + region_settings.getDayTime()); +} + +bool LLEnvManagerNew::useRegionWater() +{ + const LLEnvironmentSettings& region_settings = getRegionSettings(); + const LLSD& region_water = region_settings.getWaterParams(); + + // If region is set to defaults, + if (region_water.size() == 0) + { + // well... apply the default water settings. + return useDefaultWater(); + } + + // Otherwise apply region water. + LL_DEBUGS("Windlight") << "Applying region sky" << LL_ENDL; + return useWaterParams(region_water); +} + +bool LLEnvManagerNew::useDefaultSky() +{ + return useDayCycle("Default", LLEnvKey::SCOPE_LOCAL); +} + +bool LLEnvManagerNew::useDefaultWater() +{ + return useWaterPreset("Default"); +} + + void LLEnvManagerNew::onRegionChange(bool interpolate) { // Avoid duplicating region setting requests -- cgit v1.2.3 From 150c18169de8b7155658e676b86014716f62aeed Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Fri, 10 Jun 2011 19:55:30 +0300 Subject: STORM-1305 WIP Made LLWaterParamManager::mParamList private and typedef'ed its type. --- indra/newview/llenvmanager.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 6b506574b6..a9083cf3dc 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -884,8 +884,8 @@ void LLEnvManagerNew::dumpPresets() { LL_DEBUGS("Windlight") << " - " << region_name << LL_ENDL; } - const std::map &water_params_map = LLWaterParamManager::instance().mParamList; - for (std::map::const_iterator it = water_params_map.begin(); it != water_params_map.end(); it++) + const LLWaterParamManager::preset_map_t& water_params_map = LLWaterParamManager::instance().getPresets(); + for (LLWaterParamManager::preset_map_t::const_iterator it = water_params_map.begin(); it != water_params_map.end(); it++) { LL_DEBUGS("Windlight") << " - " << it->first << LL_ENDL; } -- cgit v1.2.3 From 23d8fb9750afc158d97fdf51633ed59b1b36f223 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Fri, 10 Jun 2011 21:21:04 +0300 Subject: STORM-1305 WIP User water presets now go first in all lists. Besides, removed all cases of direct access to the water presets map in preparation for future lazy loading. --- indra/newview/llenvmanager.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index a9083cf3dc..462e6293a8 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -884,10 +884,11 @@ void LLEnvManagerNew::dumpPresets() { LL_DEBUGS("Windlight") << " - " << region_name << LL_ENDL; } - const LLWaterParamManager::preset_map_t& water_params_map = LLWaterParamManager::instance().getPresets(); - for (LLWaterParamManager::preset_map_t::const_iterator it = water_params_map.begin(); it != water_params_map.end(); it++) + LLWaterParamManager::preset_name_list_t water_presets; + LLWaterParamManager::instance().getPresetNames(water_presets); + for (LLWaterParamManager::preset_name_list_t::const_iterator it = water_presets.begin(); it != water_presets.end(); ++it) { - LL_DEBUGS("Windlight") << " - " << it->first << LL_ENDL; + LL_DEBUGS("Windlight") << " - " << *it << LL_ENDL; } // Dump sky presets. -- cgit v1.2.3 From 4fd946fa3e5217b8f64e0fcd91d268c7eaf1bbf5 Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Fri, 10 Jun 2011 23:44:13 +0300 Subject: STORM-1305 WIP User sky presets now go first in all lists. --- indra/newview/llenvmanager.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 462e6293a8..c08ef34685 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -893,13 +893,14 @@ void LLEnvManagerNew::dumpPresets() // Dump sky presets. LL_DEBUGS("Windlight") << "Skies:" << LL_ENDL; - const std::map &sky_params_map = LLWLParamManager::getInstance()->mParamList; - for (std::map::const_iterator it = sky_params_map.begin(); it != sky_params_map.end(); it++) + LLWLParamManager::preset_key_list_t sky_preset_keys; + LLWLParamManager::instance().getPresetKeys(sky_preset_keys); + for (LLWLParamManager::preset_key_list_t::const_iterator it = sky_preset_keys.begin(); it != sky_preset_keys.end(); ++it) { - std::string preset_name = it->first.name; + std::string preset_name = it->name; std::string item_title; - if (it->first.scope == LLEnvKey::SCOPE_LOCAL) // local preset + if (it->scope == LLEnvKey::SCOPE_LOCAL) // local preset { item_title = preset_name; } -- cgit v1.2.3 From ab431d1774d5b282836a3327dd0bfa8b3b91632b Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Tue, 14 Jun 2011 18:04:29 +0300 Subject: STORM-1305 WIP User day cycles now go first in all lists. --- indra/newview/llenvmanager.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index c08ef34685..4051a4d8db 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -918,10 +918,11 @@ void LLEnvManagerNew::dumpPresets() { LL_DEBUGS("Windlight") << " - " << region_name << LL_ENDL; } - const LLDayCycleManager::dc_map_t& map = LLDayCycleManager::instance().getPresets(); - for (LLDayCycleManager::dc_map_t::const_iterator it = map.begin(); it != map.end(); ++it) + LLDayCycleManager::preset_name_list_t days; + LLDayCycleManager::instance().getPresetNames(days); + for (LLDayCycleManager::preset_name_list_t::const_iterator it = days.begin(); it != days.end(); ++it) { - LL_DEBUGS("Windlight") << " - " << it->first << LL_ENDL; + LL_DEBUGS("Windlight") << " - " << *it << LL_ENDL; } } -- cgit v1.2.3 From 31c1cff64fe6e963722e580c8779d69cef4b14ba Mon Sep 17 00:00:00 2001 From: Vadim ProductEngine Date: Wed, 6 Jul 2011 00:42:28 +0300 Subject: STORM-1262 FIXED Removed the original Windlight Region Settings implementation. --- indra/newview/llenvmanager.cpp | 544 ++--------------------------------------- 1 file changed, 17 insertions(+), 527 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index 4051a4d8db..c2720eaf28 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -35,536 +35,12 @@ #include "llenvmanager.h" #include "llagent.h" -#include "llviewerregion.h" - #include "lldaycyclemanager.h" -#include "llfloaterreg.h" -#include "llfloaterwindlight.h" -#include "llfloaterwater.h" -#include "llfloaterenvsettings.h" -#include "llwlparammanager.h" +#include "llviewercontrol.h" // for gSavedSettings +#include "llviewerregion.h" #include "llwaterparammanager.h" -#include "llfloaterregioninfo.h" -//#include "llwindlightscrubbers.h" // *HACK commented out since this code isn't released (yet) #include "llwlhandlers.h" -#include "llnotifications.h" - -extern LLControlGroup gSavedSettings; - -/*virtual*/ void LLEnvManager::initSingleton() -{ - LL_DEBUGS("Windlight") << "Initializing LLEnvManager" << LL_ENDL; - - mOrigSettingStore[LLEnvKey::SCOPE_LOCAL] = lindenDefaults(); - mCurNormalScope = (gSavedSettings.getBOOL("UseEnvironmentFromRegion") ? LLEnvKey::SCOPE_REGION : LLEnvKey::SCOPE_LOCAL); - mInterpNextChangeMessage = true; - mPendingOutgoingMessage = false; - mIsEditing = false; -} - -/******* - * Region Changes - *******/ - -void LLEnvManager::notifyLogin() -{ - changedRegion(false); -} -void LLEnvManager::notifyCrossing() -{ - changedRegion(true); -} -void LLEnvManager::notifyTP() -{ - changedRegion(false); -} -void LLEnvManager::changedRegion(bool interp) -{ - mInterpNextChangeMessage = interp; - mPendingOutgoingMessage = false; - - LLFloaterReg::hideInstance("old_env_settings"); - LLFloaterReg::hideInstance("env_settings"); - - resetInternalsToDefault(LLEnvKey::SCOPE_REGION); - - maybeClearEditingScope(LLEnvKey::SCOPE_REGION, true, false); -} - -/******* - * Editing settings / UI mode - *******/ - -void LLEnvManager::startEditingScope(LLEnvKey::EScope scope) -{ - LL_DEBUGS("Windlight") << "Starting editing scope " << scope << LL_ENDL; - - if (mIsEditing) - { - LL_WARNS("Windlight") << "Tried to start editing windlight settings while already editing some settings (possibly others)! Ignoring..." << LL_ENDL; - return; - } - if (!canEdit(scope)) - { - LL_WARNS("Windlight") << "Tried to start editing windlight settings while not allowed to! Ignoring..." << LL_ENDL; - return; - } - - mIsEditing = true; - mCurEditingScope = scope; - - // Back up local settings so that we can switch back to them later. - if (scope != LLEnvKey::SCOPE_LOCAL) - { - backUpLocalSettingsIfNeeded(); - } - - // show scope being edited - loadSettingsIntoManagers(scope, false); - - switch (scope) - { - case LLEnvKey::SCOPE_LOCAL: - // not implemented here (yet) - return; - case LLEnvKey::SCOPE_REGION: - /* LLPanelRegionTerrainInfo::instance()->setCommitControls(true); the windlight settings are no longer on the region terrain panel */ - break; - default: - return; - } -} - -void LLEnvManager::maybeClearEditingScope(LLEnvKey::EScope scope, bool user_initiated, bool was_commit) -{ - if (mIsEditing && mCurEditingScope == scope) - { - maybeClearEditingScope(user_initiated, was_commit); // handles UI, updating managers, etc. - } -} - -void LLEnvManager::maybeClearEditingScope(bool user_initiated, bool was_commit) -{ - bool clear_now = true; - if (mIsEditing && !was_commit) - { - if(user_initiated) - { - LLSD args; - args["SCOPE"] = getScopeString(mCurEditingScope); - LLNotifications::instance().add("EnvEditUnsavedChangesCancel", args, LLSD(), - boost::bind(&LLEnvManager::clearEditingScope, this, _1, _2)); - clear_now = false; - } - else - { - LLNotifications::instance().add("EnvEditExternalCancel", LLSD(), LLSD()); - } - } - - if(clear_now) - { - clearEditingScope(LLSD(), LLSD()); - } -} - -void LLEnvManager::clearEditingScope(const LLSD& notification, const LLSD& response) -{ - if(notification.isDefined() && response.isDefined() && LLNotification::getSelectedOption(notification, response) != 0) - { -#if 0 - // *TODO: select terrain panel here - mIsEditing = false; - LLFloaterReg::showTypedInstance("regioninfo"); -#endif - return; - } - - mIsEditing = false; - - updateUIFromEditability(); - /* LLPanelRegionTerrainInfo::instance()->cancelChanges(); the terrain panel no longer has windlight data - if this is needed, it should move. */ - - loadSettingsIntoManagers(mCurNormalScope, true); -} - -void LLEnvManager::updateUIFromEditability() -{ - // *TODO When the checkbox from LLFloaterEnvSettings is moved elsewhere, opening the local environment settings window should auto-display local settings - // Currently, disable all editing to ensure region settings are hidden from those that can't edit them (to preserve possibility of future tradable assets) - // Remove "!gSavedSettings.getBOOL(...)" when the desired behavior is implemented -// LLFloaterEnvSettings::instance()->setControlsEnabled(canEdit(LLEnvKey::SCOPE_LOCAL) && !gSavedSettings.getBOOL("UseEnvironmentFromRegion")); -// LLPanelRegionTerrainInfo::instance()->setEnvControls(canEdit(LLEnvKey::SCOPE_REGION)); - // enable estate UI iff canEdit(LLEnvKey::SCOPE_ESTATE), etc. -} - -bool LLEnvManager::regionCapable() -{ - return !gAgent.getRegion()->getCapability("EnvironmentSettings").empty(); -} - -const std::string LLEnvManager::getScopeString(LLEnvKey::EScope scope) -{ - switch(scope) - { - case LLEnvKey::SCOPE_LOCAL: - return LLTrans::getString("LocalSettings"); - case LLEnvKey::SCOPE_REGION: - return LLTrans::getString("RegionSettings"); - default: - return " (?)"; - } -} - -bool LLEnvManager::canEdit(LLEnvKey::EScope scope) -{ - // can't edit while a message is being sent or if already editing - if (mPendingOutgoingMessage || mIsEditing) - { - return false; - } - - // check permissions and caps - switch (scope) - { - case LLEnvKey::SCOPE_LOCAL: - return true; // always permitted to edit local - case LLEnvKey::SCOPE_REGION: - bool owner_or_god_or_manager; - { - LLViewerRegion* region = gAgent.getRegion(); - if (NULL == region || region->getCapability("EnvironmentSettings").empty()) - { - // not a windlight-aware region - return false; - } - owner_or_god_or_manager = gAgent.isGodlike() - || (region && (region->getOwner() == gAgent.getID())) - || (region && region->isEstateManager()); - } - return owner_or_god_or_manager; - default: - return false; - } -} - -/******* - * Incoming Messaging - *******/ - -void LLEnvManager::refreshFromStorage(LLEnvKey::EScope scope) -{ - // Back up local env. settings so that we can switch to them later. - if (scope != LLEnvKey::SCOPE_LOCAL) - { - backUpLocalSettingsIfNeeded(); - } - - switch (scope) - { - case LLEnvKey::SCOPE_LOCAL: - break; - case LLEnvKey::SCOPE_REGION: - if (!LLEnvironmentRequest::initiate()) - { - // don't have a cap for this, presume invalid response - processIncomingMessage(LLSD(), scope); - } - break; - default: - processIncomingMessage(LLSD(), scope); - break; - } -} - -bool LLEnvManager::processIncomingMessage(const LLSD& unvalidated_content, const LLEnvKey::EScope scope) -{ - if (scope != LLEnvKey::SCOPE_REGION) - { - return false; - } - - // Start out with defaults - resetInternalsToDefault(scope); - updateUIFromEditability(); - - // Validate - //std::set empty_set; - //LLWLPacketScrubber scrubber(scope, empty_set); - //LLSD windlight_llsd = scrubber.scrub(unvalidated_content); - - //bool valid = windlight_llsd.isDefined(); // successful scrub - - // *HACK - Don't have the validator, so just use content without validating. Should validate here for third-party grids. - LLSD windlight_llsd(unvalidated_content); - bool valid = true; - // end HACK - - mLastReceivedID = unvalidated_content[0]["messageID"].asUUID(); // if the message was valid, grab the UUID from it and save it for next outbound update message - LL_DEBUGS("Windlight Sync") << "mLastReceivedID: " << mLastReceivedID << LL_ENDL; - LL_DEBUGS("Windlight Sync") << "windlight_llsd: " << windlight_llsd << LL_ENDL; - - if (valid) - { - // TODO - the sun controls are moving; this should be updated - F32 sun_hour = 0; - LLPanelRegionTerrainInfo* terrain_panel = LLPanelRegionTerrainInfo::instance(); - - if (terrain_panel) - { - sun_hour = terrain_panel->getSunHour(); // this slider is kept up to date - } - else - { - llwarns << "Cannot instantiate the terrain panel (exiting?)" << llendl; - } - - LLWLParamManager::getInstance()->addAllSkies(scope, windlight_llsd[2]); - LLEnvironmentSettings newSettings(windlight_llsd[1], windlight_llsd[2], windlight_llsd[3], sun_hour); - mOrigSettingStore[scope] = newSettings; - } - else - { - LL_WARNS("Windlight Sync") << "Failed to parse windlight settings!" << LL_ENDL; - // presume defaults (already reset above) - } - - maybeClearEditingScope(scope, false, false); - - // refresh display with new settings, if applicable - if (mCurNormalScope == scope && !mIsEditing) // if mIsEditing still, must be editing some other scope, so don't load - { - loadSettingsIntoManagers(scope, mInterpNextChangeMessage); - } - else - { - LL_DEBUGS("Windlight Sync") << "Not loading settings (mCurNormalScope=" << mCurNormalScope << ", scope=" << scope << ", mIsEditing=" << mIsEditing << ")" << LL_ENDL; - } - - mInterpNextChangeMessage = true; // reset flag - - return valid; -} - - -/******* - * Outgoing Messaging - *******/ - -void LLEnvManager::commitSettings(LLEnvKey::EScope scope) -{ - LL_DEBUGS("Windlight Sync") << "commitSettings(scope = " << scope << ")" << LL_ENDL; - - bool success = true; - switch (scope) - { - case (LLEnvKey::SCOPE_LOCAL): - // not implemented - LLWLParamManager and LLWaterParamManager currently manage local storage themselves - break; - case (LLEnvKey::SCOPE_REGION): - mPendingOutgoingMessage = true; - LLSD metadata(LLSD::emptyMap()); - metadata["regionID"] = gAgent.getRegion()->getRegionID(); - metadata["messageID"] = mLastReceivedID; // add last received update ID to outbound message so simulator can handle concurrent updates - - saveSettingsFromManagers(scope); // save current settings into settings store before grabbing from settings store and sending - success = LLEnvironmentApply::initiateRequest(makePacket(LLEnvKey::SCOPE_REGION, metadata)); - if(success) - { - // while waiting for the return message, render old settings - // (as of Aug 09, we should get an updated RegionInfo packet, which triggers a re-request of Windlight data, which causes us to show new settings) - loadSettingsIntoManagers(LLEnvKey::SCOPE_REGION, true); - } - break; - } - - if(success) - { - // with mPendingOutgoingMessage = true, nothing is editable - updateUIFromEditability(); - maybeClearEditingScope(true, true); - } - else - { - mPendingOutgoingMessage = false; - } -} - -LLSD LLEnvManager::makePacket(LLEnvKey::EScope scope, const LLSD& metadata) -{ - return mOrigSettingStore[scope].makePacket(metadata); -} - -void LLEnvManager::commitSettingsFinished(LLEnvKey::EScope scope) -{ - mPendingOutgoingMessage = false; - - updateUIFromEditability(); -} - -void LLEnvManager::applyLocalSettingsToRegion() -{ - // Immediately apply current environment settings to region. - LLEnvManager::instance().commitSettings(LLEnvKey::SCOPE_REGION); -} - -/******* - * Loading defaults - *******/ - -void LLEnvManager::resetInternalsToDefault(LLEnvKey::EScope scope) -{ - if (LLEnvKey::SCOPE_LOCAL != scope) - { - LLWLParamManager::getInstance()->clearParamSetsOfScope(scope); - } - - mOrigSettingStore[scope] = lindenDefaults(); - LLWLParamManager::getInstance()->mAnimator.setTimeType(LLWLAnimator::TIME_LINDEN); -} - -const LLEnvironmentSettings& LLEnvManager::lindenDefaults() -{ - static bool loaded = false; - static LLEnvironmentSettings defSettings; - - if (!loaded) - { - LLWaterParamSet defaultWater; - LLWaterParamManager::instance().getParamSet("default", defaultWater); - - // *TODO save default skies (remove hack in LLWLDayCycle::loadDayCycle when this is done) - - defSettings.saveParams( - LLWLDayCycle::loadCycleDataFromFile("default.xml"), // frames will refer to local presets, which is okay - LLSD(LLSD::emptyMap()), // should never lose the default sky presets (read-only) - defaultWater.getAll(), - 0.0); - - loaded = true; - } - - return defSettings; -} - -/******* - * Manipulation of Param Managers - *******/ - -void LLEnvManager::loadSettingsIntoManagers(LLEnvKey::EScope scope, bool interpolate) -{ - LL_DEBUGS("Windlight Sync") << "Loading settings (scope = " << scope << ")" << LL_ENDL; - - LLEnvironmentSettings settings = mOrigSettingStore[scope]; - - if(interpolate) - { - LLWLParamManager::getInstance()->mAnimator.startInterpolation(settings.getWaterParams()); - } - - LLWLParamManager::getInstance()->addAllSkies(scope, settings.getSkyMap()); - LLWLParamManager::getInstance()->mDay.loadDayCycle(settings.getWLDayCycle(), scope); - LLWLParamManager::getInstance()->resetAnimator(settings.getDayTime(), true); - - LLWaterParamManager::getInstance()->mCurParams.setAll(settings.getWaterParams()); -} - -void LLEnvManager::saveSettingsFromManagers(LLEnvKey::EScope scope) -{ - LL_DEBUGS("Windlight Sync") << "Saving settings (scope = " << scope << ")" << LL_ENDL; - switch (scope) - { - case LLEnvKey::SCOPE_LOCAL: - mOrigSettingStore[scope].saveParams( - LLWLParamManager::getInstance()->mDay.asLLSD(), - LLSD(LLSD::emptyMap()), // never overwrite - LLWaterParamManager::getInstance()->mCurParams.getAll(), - LLWLParamManager::getInstance()->mAnimator.mDayTime); - break; - case LLEnvKey::SCOPE_REGION: - { - // ensure only referenced region-scope skies are saved, resolve naming collisions, etc. - std::map final_references = LLWLParamManager::getInstance()->finalizeFromDayCycle(scope); - LLSD referenced_skies = LLWLParamManager::createSkyMap(final_references); - - LL_DEBUGS("Windlight Sync") << "Dumping referenced skies (" << final_references.size() << ") to LLSD: " << referenced_skies << LL_ENDL; - - mOrigSettingStore[scope].saveParams( - LLWLParamManager::getInstance()->mDay.asLLSD(), - referenced_skies, - LLWaterParamManager::getInstance()->mCurParams.getAll(), - LLWLParamManager::getInstance()->mAnimator.mDayTime); - } - break; - default: - return; - } -} - -void LLEnvManager::backUpLocalSettingsIfNeeded() -{ - // *HACK: Back up local env. settings so that we can switch to them later. - // Otherwise local day cycle is likely to be reset. - static bool sSavedLocalSettings = false; - - if (!sSavedLocalSettings) - { - LL_DEBUGS("Windlight") << "Backing up local environment settings" << LL_ENDL; - saveSettingsFromManagers(LLEnvKey::SCOPE_LOCAL); - sSavedLocalSettings = true; - } -} - -/******* - * Setting desired display level - *******/ - -void LLEnvManager::setNormallyDisplayedScope(LLEnvKey::EScope new_scope) -{ - // temp, just save the scope directly as a value in the future when there's more than two - bool want_region = (LLEnvKey::SCOPE_REGION == new_scope); - gSavedSettings.setBOOL("UseEnvironmentFromRegion", want_region); - - if (mCurNormalScope != new_scope) - { - LL_INFOS("Windlight") << "Switching to scope " << new_scope << LL_ENDL; - mCurNormalScope = new_scope; - notifyOptInChange(); - } -} - -LLEnvKey::EScope LLEnvManager::getNormallyDisplayedScope() const -{ - return mCurNormalScope; -} - -void LLEnvManager::notifyOptInChange() -{ - bool opt_in = gSavedSettings.getBOOL("UseEnvironmentFromRegion"); - - // Save local settings if switching to region - if(opt_in) - { - LL_INFOS("Windlight") << "Saving currently-displayed settings as current local settings..." << LL_ENDL; - saveSettingsFromManagers(LLEnvKey::SCOPE_LOCAL); - } - - maybeClearEditingScope(true, false); -} - -void LLEnvManager::dumpScopes() -{ - LLSD scope_dump; - - scope_dump = makePacket(LLEnvKey::SCOPE_LOCAL, LLSD()); - LL_DEBUGS("Windlight") << "Local scope:" << scope_dump << LL_ENDL; - - scope_dump = makePacket(LLEnvKey::SCOPE_REGION, LLSD()); - LL_DEBUGS("Windlight") << "Region scope:" << scope_dump << LL_ENDL; -} - - -//============================================================================= +#include "llwlparammanager.h" std::string LLEnvPrefs::getWaterPresetName() const { @@ -973,6 +449,20 @@ bool LLEnvManagerNew::canEditRegionSettings() return owner_or_god_or_manager; } +// static +const std::string LLEnvManagerNew::getScopeString(LLEnvKey::EScope scope) +{ + switch(scope) + { + case LLEnvKey::SCOPE_LOCAL: + return LLTrans::getString("LocalSettings"); + case LLEnvKey::SCOPE_REGION: + return LLTrans::getString("RegionSettings"); + default: + return " (?)"; + } +} + void LLEnvManagerNew::onRegionCrossing() { LL_DEBUGS("Windlight") << "Crossed region" << LL_ENDL; -- cgit v1.2.3 From 9963e9aaacb2372b248ddcd37a3c5195c61a458b Mon Sep 17 00:00:00 2001 From: Oz Linden Date: Thu, 4 Aug 2011 11:00:53 -0400 Subject: fix license headers --- indra/newview/llenvmanager.cpp | 36 +++++++++++++++--------------------- 1 file changed, 15 insertions(+), 21 deletions(-) (limited to 'indra/newview/llenvmanager.cpp') diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp index c2720eaf28..86fe6754dc 100644 --- a/indra/newview/llenvmanager.cpp +++ b/indra/newview/llenvmanager.cpp @@ -2,31 +2,25 @@ * @file llenvmanager.cpp * @brief Implementation of classes managing WindLight and water settings. * - * $LicenseInfo:firstyear=2009&license=viewergpl$ - * - * Copyright (c) 2009, Linden Research, Inc. - * + * $LicenseInfo:firstyear=2009&license=viewerlgpl$ * Second Life Viewer Source Code - * The source code in this file ("Source Code") is provided by Linden Lab - * to you under the terms of the GNU General Public License, version 2.0 - * ("GPL"), unless you have obtained a separate licensing agreement - * ("Other License"), formally executed by you and Linden Lab. Terms of - * the GPL can be found in doc/GPL-license.txt in this distribution, or - * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 + * Copyright (C) 2011, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. * - * There are special exceptions to the terms and conditions of the GPL as - * it is applied to this Source Code. View the full text of the exception - * in the file doc/FLOSS-exception.txt in this software distribution, or - * online at - * http://secondlifegrid.net/programs/open_source/licensing/flossexception + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. * - * By copying, modifying or distributing this software, you acknowledge - * that you have read and understood your obligations described above, - * and agree to abide by those obligations. + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * - * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO - * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, - * COMPLETENESS OR PERFORMANCE. + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ -- cgit v1.2.3