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